starting build "1a083173-1127-4c30-801a-e2fff2192ad6"

FETCHSOURCE
BUILD
Starting Step #0
Step #0: Already have image (with digest): gcr.io/cloud-builders/git
Step #0: Cloning into 'oss-fuzz'...
Finished Step #0
Starting Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31"
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Already have image (with digest): gcr.io/cloud-builders/docker
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Sending build context to Docker daemon  18.43kB

Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 1/12 : FROM gcr.io/oss-fuzz-base/base-builder
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": latest: Pulling from oss-fuzz-base/base-builder
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b549f31133a9: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 165118fe1b27: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b206845c4ac0: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b247c08b5de5: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6192fedf3a64: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 7aba9a237063: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 2cb4ba679463: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": aed2c216d5db: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d7bf1d830004: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 1b0fe31de3cd: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 93b83b85bf37: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 33714fe02a21: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": e712f444c2be: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 4b46be3c9b60: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3c0249b6b178: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 07a06c4dfb2d: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 186c4da4724a: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 138064bacd12: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 405c549e6add: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0d9e53076a9e: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 10f5fbb131dd: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 88235c22dffa: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 76899d67d035: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 51570fcd789c: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 43d0cd0c2d77: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dfe90b65b019: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 355eb95cc498: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6c33c6181655: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b3c812841536: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": db3bd48cd0ba: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d8cd0371442b: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3ad367d5569e: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 186c4da4724a: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 93b83b85bf37: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 92e64b9b9269: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6918458b76f1: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 138064bacd12: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 33714fe02a21: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": bca3f47bdaa5: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": cec3098159e8: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 405c549e6add: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 70dd03827d03: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0d9e53076a9e: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": a35deb5183ca: Pulling fs layer
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": e712f444c2be: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 10f5fbb131dd: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 4b46be3c9b60: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 88235c22dffa: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3c0249b6b178: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 2cb4ba679463: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 07a06c4dfb2d: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 76899d67d035: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 51570fcd789c: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 43d0cd0c2d77: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dfe90b65b019: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6918458b76f1: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 355eb95cc498: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3ad367d5569e: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": aed2c216d5db: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d7bf1d830004: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 70dd03827d03: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 92e64b9b9269: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": bca3f47bdaa5: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 1b0fe31de3cd: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": a35deb5183ca: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6c33c6181655: Waiting
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b206845c4ac0: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6192fedf3a64: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6192fedf3a64: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 2cb4ba679463: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 2cb4ba679463: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": aed2c216d5db: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": aed2c216d5db: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b549f31133a9: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b549f31133a9: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b247c08b5de5: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b247c08b5de5: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 93b83b85bf37: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 93b83b85bf37: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 33714fe02a21: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 33714fe02a21: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": e712f444c2be: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 4b46be3c9b60: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 4b46be3c9b60: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 165118fe1b27: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 165118fe1b27: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 1b0fe31de3cd: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 1b0fe31de3cd: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 07a06c4dfb2d: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 07a06c4dfb2d: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3c0249b6b178: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3c0249b6b178: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 138064bacd12: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 138064bacd12: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 405c549e6add: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 186c4da4724a: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 186c4da4724a: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0d9e53076a9e: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0d9e53076a9e: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 88235c22dffa: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 88235c22dffa: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 10f5fbb131dd: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 10f5fbb131dd: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 76899d67d035: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 76899d67d035: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 51570fcd789c: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 51570fcd789c: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 43d0cd0c2d77: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 43d0cd0c2d77: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dfe90b65b019: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dfe90b65b019: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b549f31133a9: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 355eb95cc498: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6c33c6181655: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6c33c6181655: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d8cd0371442b: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": db3bd48cd0ba: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d7bf1d830004: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d7bf1d830004: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b3c812841536: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b3c812841536: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3ad367d5569e: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3ad367d5569e: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 92e64b9b9269: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 92e64b9b9269: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6918458b76f1: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": cec3098159e8: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": cec3098159e8: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": bca3f47bdaa5: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": bca3f47bdaa5: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 70dd03827d03: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 70dd03827d03: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": a35deb5183ca: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": a35deb5183ca: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 7aba9a237063: Verifying Checksum
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 7aba9a237063: Download complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 165118fe1b27: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b206845c4ac0: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b247c08b5de5: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6192fedf3a64: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 7aba9a237063: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 2cb4ba679463: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": aed2c216d5db: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d7bf1d830004: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 1b0fe31de3cd: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 93b83b85bf37: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 33714fe02a21: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": e712f444c2be: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 4b46be3c9b60: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3c0249b6b178: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 07a06c4dfb2d: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 186c4da4724a: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 138064bacd12: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 405c549e6add: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0d9e53076a9e: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 10f5fbb131dd: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 88235c22dffa: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 76899d67d035: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 51570fcd789c: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 43d0cd0c2d77: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dfe90b65b019: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 355eb95cc498: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6c33c6181655: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": b3c812841536: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": db3bd48cd0ba: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": d8cd0371442b: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 3ad367d5569e: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 92e64b9b9269: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 6918458b76f1: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": bca3f47bdaa5: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": cec3098159e8: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 70dd03827d03: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": a35deb5183ca: Pull complete
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Digest: sha256:18973cd0446a865235843ccc4f6c561d99c27da9a2d32cd0ac55960a31e32975
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Status: Downloaded newer image for gcr.io/oss-fuzz-base/base-builder:latest
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 844d79be8dcc
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 2/12 : RUN apt-get update && apt-get install python3 openjdk-11-jdk -y
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in cc55dc0c5d04
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Hit:1 http://security.ubuntu.com/ubuntu focal-security InRelease
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Hit:2 http://archive.ubuntu.com/ubuntu focal InRelease
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Hit:3 http://archive.ubuntu.com/ubuntu focal-updates InRelease
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Hit:4 http://archive.ubuntu.com/ubuntu focal-backports InRelease
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Reading package lists...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Reading package lists...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Building dependency tree...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Reading state information...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": The following packages were automatically installed and are no longer required:
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   autotools-dev libsigsegv2 m4
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Use 'apt autoremove' to remove them.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": The following additional packages will be installed:
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   alsa-topology-conf alsa-ucm-conf at-spi2-core ca-certificates-java dbus file
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   fontconfig-config fonts-dejavu-core fonts-dejavu-extra java-common
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libapparmor1 libasound2 libasound2-data libatk-bridge2.0-0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libatk-wrapper-java libatk-wrapper-java-jni libatk1.0-0 libatk1.0-data
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libatspi2.0-0 libavahi-client3 libavahi-common-data libavahi-common3
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libcups2 libdbus-1-3 libdrm-amdgpu1 libdrm-common libdrm-intel1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libdrm-nouveau2 libdrm-radeon1 libdrm2 libelf1 libfontconfig1 libfontenc1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libfreetype6 libgif7 libgl1 libgl1-mesa-dri libglapi-mesa libglib2.0-0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libglib2.0-data libglvnd0 libglx-mesa0 libglx0 libgraphite2-3 libharfbuzz0b
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libice-dev libice6 libicu66 libjpeg-turbo8 libjpeg8 liblcms2-2 libllvm12
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libmagic-mgc libmagic1 libmpdec2 libnspr4 libnss3 libpciaccess0 libpcsclite1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libpng16-16 libpthread-stubs0-dev libpython3-stdlib libpython3.8-minimal
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libpython3.8-stdlib libsensors-config libsensors5 libsm-dev libsm6
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libvulkan1 libwayland-client0 libx11-dev libx11-xcb1 libxau-dev libxaw7
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-randr0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcb-shape0 libxcb-shm0 libxcb-sync1 libxcb-xfixes0 libxcb1-dev
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcomposite1 libxdmcp-dev libxfixes3 libxft2 libxi6 libxinerama1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxkbfile1 libxml2 libxmu6 libxpm4 libxrandr2 libxrender1 libxshmfence1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxt-dev libxt6 libxtst6 libxv1 libxxf86dga1 libxxf86vm1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   mesa-vulkan-drivers mime-support openjdk-11-jdk-headless openjdk-11-jre
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   openjdk-11-jre-headless python3-minimal python3.8 python3.8-minimal
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   shared-mime-info ucf x11-common x11-utils x11proto-core-dev x11proto-dev
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   xdg-user-dirs xorg-sgml-doctools xtrans-dev
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Suggested packages:
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   default-dbus-session-bus | dbus-session-bus default-jre libasound2-plugins
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   alsa-utils cups-common libice-doc liblcms2-utils pciutils pcscd lm-sensors
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libsm-doc libx11-doc libxcb-doc libxt-doc openjdk-11-demo openjdk-11-source
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   visualvm libnss-mdns fonts-ipafont-gothic fonts-ipafont-mincho
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   fonts-wqy-microhei | fonts-wqy-zenhei fonts-indic python3-doc python3-tk
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   python3-venv python3.8-venv python3.8-doc binfmt-support mesa-utils
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": The following NEW packages will be installed:
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   alsa-topology-conf alsa-ucm-conf at-spi2-core ca-certificates-java dbus file
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   fontconfig-config fonts-dejavu-core fonts-dejavu-extra java-common
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libapparmor1 libasound2 libasound2-data libatk-bridge2.0-0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libatk-wrapper-java libatk-wrapper-java-jni libatk1.0-0 libatk1.0-data
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libatspi2.0-0 libavahi-client3 libavahi-common-data libavahi-common3
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libcups2 libdbus-1-3 libdrm-amdgpu1 libdrm-common libdrm-intel1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libdrm-nouveau2 libdrm-radeon1 libdrm2 libelf1 libfontconfig1 libfontenc1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libfreetype6 libgif7 libgl1 libgl1-mesa-dri libglapi-mesa libglib2.0-0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libglib2.0-data libglvnd0 libglx-mesa0 libglx0 libgraphite2-3 libharfbuzz0b
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libice-dev libice6 libicu66 libjpeg-turbo8 libjpeg8 liblcms2-2 libllvm12
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libmagic-mgc libmagic1 libmpdec2 libnspr4 libnss3 libpciaccess0 libpcsclite1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libpng16-16 libpthread-stubs0-dev libpython3-stdlib libpython3.8-minimal
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libpython3.8-stdlib libsensors-config libsensors5 libsm-dev libsm6
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libvulkan1 libwayland-client0 libx11-dev libx11-xcb1 libxau-dev libxaw7
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-randr0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcb-shape0 libxcb-shm0 libxcb-sync1 libxcb-xfixes0 libxcb1-dev
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxcomposite1 libxdmcp-dev libxfixes3 libxft2 libxi6 libxinerama1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxkbfile1 libxml2 libxmu6 libxpm4 libxrandr2 libxrender1 libxshmfence1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   libxt-dev libxt6 libxtst6 libxv1 libxxf86dga1 libxxf86vm1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   mesa-vulkan-drivers mime-support openjdk-11-jdk openjdk-11-jdk-headless
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   openjdk-11-jre openjdk-11-jre-headless python3 python3-minimal python3.8
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   python3.8-minimal shared-mime-info ucf x11-common x11-utils
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":   x11proto-core-dev x11proto-dev xdg-user-dirs xorg-sgml-doctools xtrans-dev
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0 upgraded, 122 newly installed, 0 to remove and 0 not upgraded.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Need to get 178 MB of archives.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": After this operation, 891 MB of additional disk space will be used.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:1 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libpython3.8-minimal amd64 3.8.10-0ubuntu1~20.04.18 [721 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:2 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 python3.8-minimal amd64 3.8.10-0ubuntu1~20.04.18 [1900 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:3 http://archive.ubuntu.com/ubuntu focal/main amd64 python3-minimal amd64 3.8.2-0ubuntu2 [23.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:4 http://archive.ubuntu.com/ubuntu focal/main amd64 mime-support all 3.64ubuntu1 [30.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:5 http://archive.ubuntu.com/ubuntu focal/main amd64 libmpdec2 amd64 2.4.2-3 [81.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:6 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libpython3.8-stdlib amd64 3.8.10-0ubuntu1~20.04.18 [1676 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:7 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 python3.8 amd64 3.8.10-0ubuntu1~20.04.18 [387 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:8 http://archive.ubuntu.com/ubuntu focal/main amd64 libpython3-stdlib amd64 3.8.2-0ubuntu2 [7068 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:9 http://archive.ubuntu.com/ubuntu focal/main amd64 python3 amd64 3.8.2-0ubuntu2 [47.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:10 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libapparmor1 amd64 2.13.3-7ubuntu5.4 [36.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:11 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdbus-1-3 amd64 1.12.16-2ubuntu2.3 [179 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:12 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 dbus amd64 1.12.16-2ubuntu2.3 [151 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:13 http://archive.ubuntu.com/ubuntu focal/main amd64 libmagic-mgc amd64 1:5.38-4 [218 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:14 http://archive.ubuntu.com/ubuntu focal/main amd64 libmagic1 amd64 1:5.38-4 [75.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:15 http://archive.ubuntu.com/ubuntu focal/main amd64 file amd64 1:5.38-4 [23.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:16 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libelf1 amd64 0.176-1.1ubuntu0.1 [44.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:17 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglib2.0-0 amd64 2.64.6-1~ubuntu20.04.9 [1290 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:18 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglib2.0-data all 2.64.6-1~ubuntu20.04.9 [5836 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:19 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libicu66 amd64 66.1-2ubuntu2.1 [8515 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:20 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libxml2 amd64 2.9.10+dfsg-5ubuntu0.20.04.10 [640 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:21 http://archive.ubuntu.com/ubuntu focal/main amd64 shared-mime-info amd64 1.15-1 [430 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:22 http://archive.ubuntu.com/ubuntu focal/main amd64 ucf all 3.0038+nmu1 [51.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:23 http://archive.ubuntu.com/ubuntu focal/main amd64 xdg-user-dirs amd64 0.17-2ubuntu1 [48.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:24 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm-common all 2.4.107-8ubuntu1~20.04.2 [5396 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:25 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm2 amd64 2.4.107-8ubuntu1~20.04.2 [34.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:26 http://archive.ubuntu.com/ubuntu focal/main amd64 libpng16-16 amd64 1.6.37-2 [179 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:27 http://archive.ubuntu.com/ubuntu focal/main amd64 alsa-topology-conf all 1.2.2-1 [7364 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:28 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 alsa-ucm-conf all 1.2.2-1ubuntu0.13 [27.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:29 http://archive.ubuntu.com/ubuntu focal/main amd64 libatspi2.0-0 amd64 2.36.0-2 [64.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:30 http://archive.ubuntu.com/ubuntu focal/main amd64 x11-common all 1:7.7+19ubuntu14 [22.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:31 http://archive.ubuntu.com/ubuntu focal/main amd64 libxtst6 amd64 2:1.2.3-1 [12.8 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:32 http://archive.ubuntu.com/ubuntu focal/main amd64 at-spi2-core amd64 2.36.0-2 [48.7 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:33 http://archive.ubuntu.com/ubuntu focal/main amd64 java-common all 0.72 [6816 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:34 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libavahi-common-data amd64 0.7-4ubuntu7.3 [21.4 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:35 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libavahi-common3 amd64 0.7-4ubuntu7.3 [21.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:36 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libavahi-client3 amd64 0.7-4ubuntu7.3 [25.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:37 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libcups2 amd64 2.3.1-9ubuntu1.9 [234 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:38 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libfreetype6 amd64 2.10.1-2ubuntu0.4 [341 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:39 http://archive.ubuntu.com/ubuntu focal/main amd64 fonts-dejavu-core all 2.37-1 [1041 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:40 http://archive.ubuntu.com/ubuntu focal/main amd64 fontconfig-config all 2.13.1-2ubuntu3 [28.8 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:41 http://archive.ubuntu.com/ubuntu focal/main amd64 libfontconfig1 amd64 2.13.1-2ubuntu3 [114 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:42 http://archive.ubuntu.com/ubuntu focal/main amd64 liblcms2-2 amd64 2.9-4 [140 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:43 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libjpeg-turbo8 amd64 2.0.3-0ubuntu1.20.04.3 [118 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:44 http://archive.ubuntu.com/ubuntu focal/main amd64 libjpeg8 amd64 8c-2ubuntu8 [2194 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:45 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libnspr4 amd64 2:4.35-0ubuntu0.20.04.1 [108 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:46 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libnss3 amd64 2:3.98-0ubuntu0.20.04.2 [1391 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:47 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libasound2-data all 1.2.2-2.1ubuntu2.5 [20.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:48 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libasound2 amd64 1.2.2-2.1ubuntu2.5 [335 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:49 http://archive.ubuntu.com/ubuntu focal/main amd64 libgraphite2-3 amd64 1.3.13-11build1 [73.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:50 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libharfbuzz0b amd64 2.6.4-1ubuntu4.3 [391 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:51 http://archive.ubuntu.com/ubuntu focal/main amd64 libpcsclite1 amd64 1.8.26-3 [22.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:52 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 openjdk-11-jre-headless amd64 11.0.27+6~us1-0ubuntu1~20.04 [38.3 MB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:53 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 ca-certificates-java all 20190405ubuntu1.1 [12.4 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:54 http://archive.ubuntu.com/ubuntu focal/main amd64 fonts-dejavu-extra all 2.37-1 [1953 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:55 http://archive.ubuntu.com/ubuntu focal/main amd64 libatk1.0-data all 2.35.1-1ubuntu2 [2964 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:56 http://archive.ubuntu.com/ubuntu focal/main amd64 libatk1.0-0 amd64 2.35.1-1ubuntu2 [45.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:57 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libatk-bridge2.0-0 amd64 2.34.2-0ubuntu2~20.04.1 [58.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:58 http://archive.ubuntu.com/ubuntu focal/main amd64 libfontenc1 amd64 1:1.1.4-0ubuntu1 [14.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:59 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglvnd0 amd64 1.3.2-1~ubuntu0.20.04.2 [48.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:60 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglapi-mesa amd64 21.2.6-0ubuntu0.1~20.04.2 [27.4 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:61 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libx11-xcb1 amd64 2:1.6.9-2ubuntu1.6 [9448 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:62 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-dri2-0 amd64 1.14-2 [6920 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:63 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-dri3-0 amd64 1.14-2 [6552 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:64 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-glx0 amd64 1.14-2 [22.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:65 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-present0 amd64 1.14-2 [5560 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:66 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-shm0 amd64 1.14-2 [5584 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:67 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-sync1 amd64 1.14-2 [8884 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:68 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-xfixes0 amd64 1.14-2 [9296 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:69 http://archive.ubuntu.com/ubuntu focal/main amd64 libxfixes3 amd64 1:5.0.3-2 [10.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:70 http://archive.ubuntu.com/ubuntu focal/main amd64 libxshmfence1 amd64 1.3-1 [5028 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:71 http://archive.ubuntu.com/ubuntu focal/main amd64 libxxf86vm1 amd64 1:1.1.4-1build1 [10.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:72 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm-amdgpu1 amd64 2.4.107-8ubuntu1~20.04.2 [18.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:73 http://archive.ubuntu.com/ubuntu focal/main amd64 libpciaccess0 amd64 0.16-0ubuntu1 [17.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:74 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm-intel1 amd64 2.4.107-8ubuntu1~20.04.2 [60.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:75 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm-nouveau2 amd64 2.4.107-8ubuntu1~20.04.2 [16.6 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:76 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libdrm-radeon1 amd64 2.4.107-8ubuntu1~20.04.2 [19.7 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:77 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libllvm12 amd64 1:12.0.0-3ubuntu1~20.04.5 [18.8 MB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:78 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libsensors-config all 1:3.6.0-2ubuntu1.1 [6052 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:79 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libsensors5 amd64 1:3.6.0-2ubuntu1.1 [27.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:80 http://archive.ubuntu.com/ubuntu focal/main amd64 libvulkan1 amd64 1.2.131.2-1 [93.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:81 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libgl1-mesa-dri amd64 21.2.6-0ubuntu0.1~20.04.2 [11.0 MB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:82 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglx-mesa0 amd64 21.2.6-0ubuntu0.1~20.04.2 [137 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:83 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libglx0 amd64 1.3.2-1~ubuntu0.20.04.2 [32.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:84 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libgl1 amd64 1.3.2-1~ubuntu0.20.04.2 [85.8 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:85 http://archive.ubuntu.com/ubuntu focal/main amd64 libice6 amd64 2:1.0.10-0ubuntu1 [41.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:86 http://archive.ubuntu.com/ubuntu focal/main amd64 libsm6 amd64 2:1.2.3-1 [16.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:87 http://archive.ubuntu.com/ubuntu focal/main amd64 libxt6 amd64 1:1.1.5-1 [160 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:88 http://archive.ubuntu.com/ubuntu focal/main amd64 libxmu6 amd64 2:1.1.3-0ubuntu1 [45.8 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:89 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libxpm4 amd64 1:3.5.12-1ubuntu0.20.04.2 [34.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:90 http://archive.ubuntu.com/ubuntu focal/main amd64 libxaw7 amd64 2:1.0.13-1 [173 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:91 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-shape0 amd64 1.14-2 [5928 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:92 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcomposite1 amd64 1:0.4.5-1 [6976 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:93 http://archive.ubuntu.com/ubuntu focal/main amd64 libxrender1 amd64 1:0.9.10-1 [18.7 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:94 http://archive.ubuntu.com/ubuntu focal/main amd64 libxft2 amd64 2.3.3-0ubuntu1 [39.2 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:95 http://archive.ubuntu.com/ubuntu focal/main amd64 libxi6 amd64 2:1.7.10-0ubuntu1 [29.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:96 http://archive.ubuntu.com/ubuntu focal/main amd64 libxinerama1 amd64 2:1.1.4-2 [6904 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:97 http://archive.ubuntu.com/ubuntu focal/main amd64 libxkbfile1 amd64 1:1.1.0-1 [65.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:98 http://archive.ubuntu.com/ubuntu focal/main amd64 libxrandr2 amd64 2:1.5.2-0ubuntu1 [18.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:99 http://archive.ubuntu.com/ubuntu focal/main amd64 libxv1 amd64 2:1.0.11-1 [10.7 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:100 http://archive.ubuntu.com/ubuntu focal/main amd64 libxxf86dga1 amd64 2:1.1.5-0ubuntu1 [12.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:101 http://archive.ubuntu.com/ubuntu focal/main amd64 x11-utils amd64 7.7+5 [199 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:102 http://archive.ubuntu.com/ubuntu focal/main amd64 libatk-wrapper-java all 0.37.1-1 [53.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:103 http://archive.ubuntu.com/ubuntu focal/main amd64 libatk-wrapper-java-jni amd64 0.37.1-1 [45.1 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:104 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libgif7 amd64 5.1.9-1ubuntu0.1 [32.4 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:105 http://archive.ubuntu.com/ubuntu focal/main amd64 xorg-sgml-doctools all 1:1.11-1 [12.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:106 http://archive.ubuntu.com/ubuntu focal/main amd64 x11proto-dev all 2019.2-1ubuntu1 [594 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:107 http://archive.ubuntu.com/ubuntu focal/main amd64 x11proto-core-dev all 2019.2-1ubuntu1 [2620 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:108 http://archive.ubuntu.com/ubuntu focal/main amd64 libice-dev amd64 2:1.0.10-0ubuntu1 [47.8 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:109 http://archive.ubuntu.com/ubuntu focal/main amd64 libpthread-stubs0-dev amd64 0.4-1 [5384 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:110 http://archive.ubuntu.com/ubuntu focal/main amd64 libsm-dev amd64 2:1.2.3-1 [17.0 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:111 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libwayland-client0 amd64 1.18.0-1ubuntu0.1 [23.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:112 http://archive.ubuntu.com/ubuntu focal/main amd64 libxau-dev amd64 1:1.0.9-0ubuntu1 [9552 B]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:113 http://archive.ubuntu.com/ubuntu focal/main amd64 libxdmcp-dev amd64 1:1.1.3-0ubuntu1 [25.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:114 http://archive.ubuntu.com/ubuntu focal/main amd64 xtrans-dev all 1.4.0-1 [68.9 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:115 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb1-dev amd64 1.14-2 [80.5 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:116 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 libx11-dev amd64 2:1.6.9-2ubuntu1.6 [648 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:117 http://archive.ubuntu.com/ubuntu focal/main amd64 libxcb-randr0 amd64 1.14-2 [16.3 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:118 http://archive.ubuntu.com/ubuntu focal/main amd64 libxt-dev amd64 1:1.1.5-1 [395 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:119 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 mesa-vulkan-drivers amd64 21.2.6-0ubuntu0.1~20.04.2 [5788 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:120 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 openjdk-11-jre amd64 11.0.27+6~us1-0ubuntu1~20.04 [194 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:121 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 openjdk-11-jdk-headless amd64 11.0.27+6~us1-0ubuntu1~20.04 [73.8 MB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Get:122 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 openjdk-11-jdk amd64 11.0.27+6~us1-0ubuntu1~20.04 [2876 kB]
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": debconf: delaying package configuration, since apt-utils is not installed
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Fetched 178 MB in 3s (67.6 MB/s)
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpython3.8-minimal:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": (Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 17483 files and directories currently installed.)
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../libpython3.8-minimal_3.8.10-0ubuntu1~20.04.18_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpython3.8-minimal:amd64 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package python3.8-minimal.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../python3.8-minimal_3.8.10-0ubuntu1~20.04.18_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking python3.8-minimal (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpython3.8-minimal:amd64 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up python3.8-minimal (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package python3-minimal.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": (Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 17766 files and directories currently installed.)
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../0-python3-minimal_3.8.2-0ubuntu2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking python3-minimal (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package mime-support.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../1-mime-support_3.64ubuntu1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking mime-support (3.64ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libmpdec2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../2-libmpdec2_2.4.2-3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libmpdec2:amd64 (2.4.2-3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpython3.8-stdlib:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../3-libpython3.8-stdlib_3.8.10-0ubuntu1~20.04.18_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpython3.8-stdlib:amd64 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package python3.8.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../4-python3.8_3.8.10-0ubuntu1~20.04.18_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking python3.8 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpython3-stdlib:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../5-libpython3-stdlib_3.8.2-0ubuntu2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpython3-stdlib:amd64 (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up python3-minimal (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package python3.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": (Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 18168 files and directories currently installed.)
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../000-python3_3.8.2-0ubuntu2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking python3 (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libapparmor1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../001-libapparmor1_2.13.3-7ubuntu5.4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libapparmor1:amd64 (2.13.3-7ubuntu5.4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdbus-1-3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../002-libdbus-1-3_1.12.16-2ubuntu2.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdbus-1-3:amd64 (1.12.16-2ubuntu2.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package dbus.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../003-dbus_1.12.16-2ubuntu2.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking dbus (1.12.16-2ubuntu2.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libmagic-mgc.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../004-libmagic-mgc_1%3a5.38-4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libmagic-mgc (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libmagic1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../005-libmagic1_1%3a5.38-4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libmagic1:amd64 (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package file.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../006-file_1%3a5.38-4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking file (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libelf1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../007-libelf1_0.176-1.1ubuntu0.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libelf1:amd64 (0.176-1.1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglib2.0-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../008-libglib2.0-0_2.64.6-1~ubuntu20.04.9_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglib2.0-0:amd64 (2.64.6-1~ubuntu20.04.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglib2.0-data.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../009-libglib2.0-data_2.64.6-1~ubuntu20.04.9_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglib2.0-data (2.64.6-1~ubuntu20.04.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libicu66:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../010-libicu66_66.1-2ubuntu2.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libicu66:amd64 (66.1-2ubuntu2.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxml2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../011-libxml2_2.9.10+dfsg-5ubuntu0.20.04.10_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxml2:amd64 (2.9.10+dfsg-5ubuntu0.20.04.10) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package shared-mime-info.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../012-shared-mime-info_1.15-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking shared-mime-info (1.15-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package ucf.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../013-ucf_3.0038+nmu1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Moving old data out of the way
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking ucf (3.0038+nmu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package xdg-user-dirs.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../014-xdg-user-dirs_0.17-2ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking xdg-user-dirs (0.17-2ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm-common.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../015-libdrm-common_2.4.107-8ubuntu1~20.04.2_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm-common (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../016-libdrm2_2.4.107-8ubuntu1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm2:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpng16-16:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../017-libpng16-16_1.6.37-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpng16-16:amd64 (1.6.37-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package alsa-topology-conf.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../018-alsa-topology-conf_1.2.2-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking alsa-topology-conf (1.2.2-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package alsa-ucm-conf.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../019-alsa-ucm-conf_1.2.2-1ubuntu0.13_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking alsa-ucm-conf (1.2.2-1ubuntu0.13) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatspi2.0-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../020-libatspi2.0-0_2.36.0-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatspi2.0-0:amd64 (2.36.0-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package x11-common.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../021-x11-common_1%3a7.7+19ubuntu14_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": dpkg-query: no packages found matching nux-tools
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking x11-common (1:7.7+19ubuntu14) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxtst6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../022-libxtst6_2%3a1.2.3-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxtst6:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package at-spi2-core.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../023-at-spi2-core_2.36.0-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking at-spi2-core (2.36.0-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package java-common.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../024-java-common_0.72_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking java-common (0.72) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libavahi-common-data:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../025-libavahi-common-data_0.7-4ubuntu7.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libavahi-common-data:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libavahi-common3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../026-libavahi-common3_0.7-4ubuntu7.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libavahi-common3:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libavahi-client3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../027-libavahi-client3_0.7-4ubuntu7.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libavahi-client3:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libcups2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../028-libcups2_2.3.1-9ubuntu1.9_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libcups2:amd64 (2.3.1-9ubuntu1.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libfreetype6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../029-libfreetype6_2.10.1-2ubuntu0.4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libfreetype6:amd64 (2.10.1-2ubuntu0.4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package fonts-dejavu-core.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../030-fonts-dejavu-core_2.37-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking fonts-dejavu-core (2.37-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package fontconfig-config.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../031-fontconfig-config_2.13.1-2ubuntu3_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking fontconfig-config (2.13.1-2ubuntu3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libfontconfig1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../032-libfontconfig1_2.13.1-2ubuntu3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libfontconfig1:amd64 (2.13.1-2ubuntu3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package liblcms2-2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../033-liblcms2-2_2.9-4_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking liblcms2-2:amd64 (2.9-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libjpeg-turbo8:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../034-libjpeg-turbo8_2.0.3-0ubuntu1.20.04.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libjpeg-turbo8:amd64 (2.0.3-0ubuntu1.20.04.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libjpeg8:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../035-libjpeg8_8c-2ubuntu8_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libjpeg8:amd64 (8c-2ubuntu8) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libnspr4:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../036-libnspr4_2%3a4.35-0ubuntu0.20.04.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libnspr4:amd64 (2:4.35-0ubuntu0.20.04.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libnss3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../037-libnss3_2%3a3.98-0ubuntu0.20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libnss3:amd64 (2:3.98-0ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libasound2-data.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../038-libasound2-data_1.2.2-2.1ubuntu2.5_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libasound2-data (1.2.2-2.1ubuntu2.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libasound2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../039-libasound2_1.2.2-2.1ubuntu2.5_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libasound2:amd64 (1.2.2-2.1ubuntu2.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libgraphite2-3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../040-libgraphite2-3_1.3.13-11build1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libgraphite2-3:amd64 (1.3.13-11build1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libharfbuzz0b:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../041-libharfbuzz0b_2.6.4-1ubuntu4.3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libharfbuzz0b:amd64 (2.6.4-1ubuntu4.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpcsclite1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../042-libpcsclite1_1.8.26-3_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpcsclite1:amd64 (1.8.26-3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package openjdk-11-jre-headless:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../043-openjdk-11-jre-headless_11.0.27+6~us1-0ubuntu1~20.04_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking openjdk-11-jre-headless:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package ca-certificates-java.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../044-ca-certificates-java_20190405ubuntu1.1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking ca-certificates-java (20190405ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package fonts-dejavu-extra.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../045-fonts-dejavu-extra_2.37-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking fonts-dejavu-extra (2.37-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatk1.0-data.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../046-libatk1.0-data_2.35.1-1ubuntu2_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatk1.0-data (2.35.1-1ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatk1.0-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../047-libatk1.0-0_2.35.1-1ubuntu2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatk1.0-0:amd64 (2.35.1-1ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatk-bridge2.0-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../048-libatk-bridge2.0-0_2.34.2-0ubuntu2~20.04.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatk-bridge2.0-0:amd64 (2.34.2-0ubuntu2~20.04.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libfontenc1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../049-libfontenc1_1%3a1.1.4-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libfontenc1:amd64 (1:1.1.4-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglvnd0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../050-libglvnd0_1.3.2-1~ubuntu0.20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglvnd0:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglapi-mesa:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../051-libglapi-mesa_21.2.6-0ubuntu0.1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglapi-mesa:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libx11-xcb1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../052-libx11-xcb1_2%3a1.6.9-2ubuntu1.6_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libx11-xcb1:amd64 (2:1.6.9-2ubuntu1.6) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-dri2-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../053-libxcb-dri2-0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-dri2-0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-dri3-0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../054-libxcb-dri3-0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-dri3-0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-glx0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../055-libxcb-glx0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-glx0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-present0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../056-libxcb-present0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-present0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-shm0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../057-libxcb-shm0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-shm0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-sync1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../058-libxcb-sync1_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-sync1:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-xfixes0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../059-libxcb-xfixes0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-xfixes0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxfixes3:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../060-libxfixes3_1%3a5.0.3-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxfixes3:amd64 (1:5.0.3-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxshmfence1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../061-libxshmfence1_1.3-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxshmfence1:amd64 (1.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxxf86vm1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../062-libxxf86vm1_1%3a1.1.4-1build1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxxf86vm1:amd64 (1:1.1.4-1build1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm-amdgpu1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../063-libdrm-amdgpu1_2.4.107-8ubuntu1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm-amdgpu1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpciaccess0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../064-libpciaccess0_0.16-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpciaccess0:amd64 (0.16-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm-intel1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../065-libdrm-intel1_2.4.107-8ubuntu1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm-intel1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm-nouveau2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../066-libdrm-nouveau2_2.4.107-8ubuntu1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm-nouveau2:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libdrm-radeon1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../067-libdrm-radeon1_2.4.107-8ubuntu1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libdrm-radeon1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libllvm12:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../068-libllvm12_1%3a12.0.0-3ubuntu1~20.04.5_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libllvm12:amd64 (1:12.0.0-3ubuntu1~20.04.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libsensors-config.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../069-libsensors-config_1%3a3.6.0-2ubuntu1.1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libsensors-config (1:3.6.0-2ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libsensors5:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../070-libsensors5_1%3a3.6.0-2ubuntu1.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libsensors5:amd64 (1:3.6.0-2ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libvulkan1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../071-libvulkan1_1.2.131.2-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libvulkan1:amd64 (1.2.131.2-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libgl1-mesa-dri:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../072-libgl1-mesa-dri_21.2.6-0ubuntu0.1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libgl1-mesa-dri:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglx-mesa0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../073-libglx-mesa0_21.2.6-0ubuntu0.1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglx-mesa0:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libglx0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../074-libglx0_1.3.2-1~ubuntu0.20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libglx0:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libgl1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../075-libgl1_1.3.2-1~ubuntu0.20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libgl1:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libice6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../076-libice6_2%3a1.0.10-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libice6:amd64 (2:1.0.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libsm6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../077-libsm6_2%3a1.2.3-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libsm6:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxt6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../078-libxt6_1%3a1.1.5-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxt6:amd64 (1:1.1.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxmu6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../079-libxmu6_2%3a1.1.3-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxmu6:amd64 (2:1.1.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxpm4:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../080-libxpm4_1%3a3.5.12-1ubuntu0.20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxpm4:amd64 (1:3.5.12-1ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxaw7:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../081-libxaw7_2%3a1.0.13-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxaw7:amd64 (2:1.0.13-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-shape0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../082-libxcb-shape0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-shape0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcomposite1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../083-libxcomposite1_1%3a0.4.5-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcomposite1:amd64 (1:0.4.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxrender1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../084-libxrender1_1%3a0.9.10-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxrender1:amd64 (1:0.9.10-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxft2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../085-libxft2_2.3.3-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxft2:amd64 (2.3.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxi6:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../086-libxi6_2%3a1.7.10-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxi6:amd64 (2:1.7.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxinerama1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../087-libxinerama1_2%3a1.1.4-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxinerama1:amd64 (2:1.1.4-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxkbfile1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../088-libxkbfile1_1%3a1.1.0-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxkbfile1:amd64 (1:1.1.0-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxrandr2:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../089-libxrandr2_2%3a1.5.2-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxrandr2:amd64 (2:1.5.2-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxv1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../090-libxv1_2%3a1.0.11-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxv1:amd64 (2:1.0.11-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxxf86dga1:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../091-libxxf86dga1_2%3a1.1.5-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxxf86dga1:amd64 (2:1.1.5-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package x11-utils.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../092-x11-utils_7.7+5_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking x11-utils (7.7+5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatk-wrapper-java.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../093-libatk-wrapper-java_0.37.1-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatk-wrapper-java (0.37.1-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libatk-wrapper-java-jni:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../094-libatk-wrapper-java-jni_0.37.1-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libatk-wrapper-java-jni:amd64 (0.37.1-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libgif7:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../095-libgif7_5.1.9-1ubuntu0.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libgif7:amd64 (5.1.9-1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package xorg-sgml-doctools.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../096-xorg-sgml-doctools_1%3a1.11-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking xorg-sgml-doctools (1:1.11-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package x11proto-dev.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../097-x11proto-dev_2019.2-1ubuntu1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking x11proto-dev (2019.2-1ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package x11proto-core-dev.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../098-x11proto-core-dev_2019.2-1ubuntu1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking x11proto-core-dev (2019.2-1ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libice-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../099-libice-dev_2%3a1.0.10-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libice-dev:amd64 (2:1.0.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libpthread-stubs0-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../100-libpthread-stubs0-dev_0.4-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libpthread-stubs0-dev:amd64 (0.4-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libsm-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../101-libsm-dev_2%3a1.2.3-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libsm-dev:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libwayland-client0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../102-libwayland-client0_1.18.0-1ubuntu0.1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libwayland-client0:amd64 (1.18.0-1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxau-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../103-libxau-dev_1%3a1.0.9-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxau-dev:amd64 (1:1.0.9-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxdmcp-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../104-libxdmcp-dev_1%3a1.1.3-0ubuntu1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxdmcp-dev:amd64 (1:1.1.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package xtrans-dev.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../105-xtrans-dev_1.4.0-1_all.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking xtrans-dev (1.4.0-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb1-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../106-libxcb1-dev_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb1-dev:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libx11-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../107-libx11-dev_2%3a1.6.9-2ubuntu1.6_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libx11-dev:amd64 (2:1.6.9-2ubuntu1.6) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxcb-randr0:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../108-libxcb-randr0_1.14-2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxcb-randr0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package libxt-dev:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../109-libxt-dev_1%3a1.1.5-1_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking libxt-dev:amd64 (1:1.1.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package mesa-vulkan-drivers:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../110-mesa-vulkan-drivers_21.2.6-0ubuntu0.1~20.04.2_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking mesa-vulkan-drivers:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package openjdk-11-jre:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../111-openjdk-11-jre_11.0.27+6~us1-0ubuntu1~20.04_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking openjdk-11-jre:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package openjdk-11-jdk-headless:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../112-openjdk-11-jdk-headless_11.0.27+6~us1-0ubuntu1~20.04_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking openjdk-11-jdk-headless:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Selecting previously unselected package openjdk-11-jdk:amd64.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Preparing to unpack .../113-openjdk-11-jdk_11.0.27+6~us1-0ubuntu1~20.04_amd64.deb ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Unpacking openjdk-11-jdk:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libgraphite2-3:amd64 (1.3.13-11build1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-dri3-0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up liblcms2-2:amd64 (2.9-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libx11-xcb1:amd64 (2:1.6.9-2ubuntu1.6) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpciaccess0:amd64 (0.16-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libapparmor1:amd64 (2.13.3-7ubuntu5.4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-xfixes0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up mime-support (3.64ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxpm4:amd64 (1:3.5.12-1ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxi6:amd64 (2:1.7.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up java-common (0.72) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxrender1:amd64 (1:0.9.10-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up xdg-user-dirs (0.17-2ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up alsa-ucm-conf (1.2.2-1ubuntu0.13) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libmagic-mgc (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglib2.0-0:amd64 (2.64.6-1~ubuntu20.04.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": No schema files found: doing nothing.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglvnd0:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libicu66:amd64 (66.1-2ubuntu2.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-glx0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-shape0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up x11-common (1:7.7+19ubuntu14) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-rc.d: warning: start and stop actions are no longer supported; falling back to defaults
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": invoke-rc.d: could not determine current runlevel
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": invoke-rc.d: policy-rc.d denied execution of start.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libsensors-config (1:3.6.0-2ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libmagic1:amd64 (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxxf86dga1:amd64 (2:1.1.5-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-shm0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up file (1:5.38-4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpthread-stubs0-dev:amd64 (0.4-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxxf86vm1:amd64 (1:1.1.4-1build1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-present0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libasound2-data (1.2.2-2.1ubuntu2.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up xtrans-dev (1.4.0-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libfontenc1:amd64 (1:1.1.4-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglib2.0-data (2.64.6-1~ubuntu20.04.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libnspr4:amd64 (2:4.35-0ubuntu0.20.04.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxfixes3:amd64 (1:5.0.3-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-sync1:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libavahi-common-data:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libllvm12:amd64 (1:12.0.0-3ubuntu1~20.04.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdbus-1-3:amd64 (1.12.16-2ubuntu2.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up dbus (1.12.16-2ubuntu2.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxinerama1:amd64 (2:1.1.4-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxv1:amd64 (2:1.0.11-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpng16-16:amd64 (1.6.37-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxrandr2:amd64 (2:1.5.2-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up fonts-dejavu-core (2.37-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpcsclite1:amd64 (1.8.26-3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up ucf (3.0038+nmu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libsensors5:amd64 (1:3.6.0-2ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libjpeg-turbo8:amd64 (2.0.3-0ubuntu1.20.04.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglapi-mesa:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libvulkan1:amd64 (1.2.131.2-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-dri2-0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libgif7:amd64 (5.1.9-1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatk1.0-data (2.35.1-1ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up fonts-dejavu-extra (2.37-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up alsa-topology-conf (1.2.2-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxshmfence1:amd64 (1.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb-randr0:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libasound2:amd64 (1.2.2-2.1ubuntu2.5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up xorg-sgml-doctools (1:1.11-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatk1.0-0:amd64 (2.35.1-1ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxkbfile1:amd64 (1:1.1.0-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libmpdec2:amd64 (2.4.2-3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpython3.8-stdlib:amd64 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up python3.8 (3.8.10-0ubuntu1~20.04.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm-common (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libelf1:amd64 (0.176-1.1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcomposite1:amd64 (1:0.4.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxml2:amd64 (2.9.10+dfsg-5ubuntu0.20.04.10) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libpython3-stdlib:amd64 (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libwayland-client0:amd64 (1.18.0-1ubuntu0.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libjpeg8:amd64 (8c-2ubuntu8) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up x11proto-dev (2019.2-1ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libice6:amd64 (2:1.0.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxau-dev:amd64 (1:1.0.9-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libice-dev:amd64 (2:1.0.10-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up fontconfig-config (2.13.1-2ubuntu3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxtst6:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libavahi-common3:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up python3 (3.8.2-0ubuntu2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libnss3:amd64 (2:3.98-0ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatspi2.0-0:amd64 (2.36.0-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatk-bridge2.0-0:amd64 (2.34.2-0ubuntu2~20.04.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxdmcp-dev:amd64 (1:1.1.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libfreetype6:amd64 (2.10.1-2ubuntu0.4) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up x11proto-core-dev (2019.2-1ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up shared-mime-info (1.15-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm2:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up at-spi2-core (2.36.0-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libharfbuzz0b:amd64 (2.6.4-1ubuntu4.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libfontconfig1:amd64 (2.13.1-2ubuntu3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libsm6:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libavahi-client3:amd64 (0.7-4ubuntu7.3) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm-amdgpu1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up mesa-vulkan-drivers:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxft2:amd64 (2.3.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm-nouveau2:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxcb1-dev:amd64 (1.14-2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libsm-dev:amd64 (2:1.2.3-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm-radeon1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libdrm-intel1:amd64 (2.4.107-8ubuntu1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libgl1-mesa-dri:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libx11-dev:amd64 (2:1.6.9-2ubuntu1.6) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxt6:amd64 (1:1.1.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libcups2:amd64 (2.3.1-9ubuntu1.9) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxmu6:amd64 (2:1.1.3-0ubuntu1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglx-mesa0:amd64 (21.2.6-0ubuntu0.1~20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libglx0:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxaw7:amd64 (2:1.0.13-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libgl1:amd64 (1.3.2-1~ubuntu0.20.04.2) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libxt-dev:amd64 (1:1.1.5-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up x11-utils (7.7+5) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatk-wrapper-java (0.37.1-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up libatk-wrapper-java-jni:amd64 (0.37.1-1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up openjdk-11-jre-headless:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/java to provide /usr/bin/java (java) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jjs to provide /usr/bin/jjs (jjs) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/keytool to provide /usr/bin/keytool (keytool) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/rmid to provide /usr/bin/rmid (rmid) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/rmiregistry to provide /usr/bin/rmiregistry (rmiregistry) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/pack200 to provide /usr/bin/pack200 (pack200) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/unpack200 to provide /usr/bin/unpack200 (unpack200) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/lib/jexec to provide /usr/bin/jexec (jexec) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up openjdk-11-jre:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up openjdk-11-jdk-headless:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jar to provide /usr/bin/jar (jar) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jarsigner to provide /usr/bin/jarsigner (jarsigner) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/javac to provide /usr/bin/javac (javac) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/javadoc to provide /usr/bin/javadoc (javadoc) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/javap to provide /usr/bin/javap (javap) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jcmd to provide /usr/bin/jcmd (jcmd) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jdb to provide /usr/bin/jdb (jdb) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jdeprscan to provide /usr/bin/jdeprscan (jdeprscan) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jdeps to provide /usr/bin/jdeps (jdeps) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jfr to provide /usr/bin/jfr (jfr) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jimage to provide /usr/bin/jimage (jimage) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jinfo to provide /usr/bin/jinfo (jinfo) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jlink to provide /usr/bin/jlink (jlink) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jmap to provide /usr/bin/jmap (jmap) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jmod to provide /usr/bin/jmod (jmod) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jps to provide /usr/bin/jps (jps) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jrunscript to provide /usr/bin/jrunscript (jrunscript) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jshell to provide /usr/bin/jshell (jshell) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jstack to provide /usr/bin/jstack (jstack) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jstat to provide /usr/bin/jstat (jstat) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jstatd to provide /usr/bin/jstatd (jstatd) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/rmic to provide /usr/bin/rmic (rmic) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/serialver to provide /usr/bin/serialver (serialver) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jaotc to provide /usr/bin/jaotc (jaotc) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jhsdb to provide /usr/bin/jhsdb (jhsdb) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up openjdk-11-jdk:amd64 (11.0.27+6~us1-0ubuntu1~20.04) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": update-alternatives: using /usr/lib/jvm/java-11-openjdk-amd64/bin/jconsole to provide /usr/bin/jconsole (jconsole) in auto mode
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Setting up ca-certificates-java (20190405ubuntu1.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": head: cannot open '/etc/ssl/certs/java/cacerts' for reading: No such file or directory
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:QuoVadis_Root_CA_2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Global_Root_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:emSign_Root_CA_-_G1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certum_Trusted_Network_CA_2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_TLS_ECC_P384_Root_G5.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Hongkong_Post_Root_CA_3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:XRamp_Global_CA_Root.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_TLS_RSA4096_Root_G5.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TWCA_Global_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CommScope_Public_Trust_RSA_Root-01.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:USERTrust_ECC_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:QuoVadis_Root_CA_1_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:COMODO_ECC_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:T-TeleSec_GlobalRoot_Class_2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:COMODO_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certigna_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Go_Daddy_Class_2_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Trustwave_Global_ECC_P384_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:HiPKI_Root_CA_-_G1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Starfield_Services_Root_Certificate_Authority_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Security_Communication_ECC_RootCA1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:UCA_Global_G2_Root.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GTS_Root_R2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:certSIGN_ROOT_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CommScope_Public_Trust_RSA_Root-02.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:emSign_ECC_Root_CA_-_C3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Trusted_Root_G4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:vTrus_ECC_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:BJCA_Global_Root_CA1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:D-TRUST_BR_Root_CA_1_2020.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_Root_CA_-_R3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Amazon_Root_CA_4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_Root_Certification_Authority_ECC.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GTS_Root_R1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AffirmTrust_Commercial.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Sectigo_Public_Server_Authentication_Root_R46.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Starfield_Class_2_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AffirmTrust_Networking.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Entrust_Root_Certification_Authority_-_G4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Comodo_AAA_Services_root.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certainly_Root_R1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SwissSign_Gold_CA_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CommScope_Public_Trust_ECC_Root-01.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Global_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Microsoft_RSA_Root_Certificate_Authority_2017.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:OISTE_WISeKey_Global_Root_GC_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:ISRG_Root_X2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GLOBALTRUST_2020.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:D-TRUST_Root_Class_3_CA_2_EV_2009.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:ISRG_Root_X1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Trustwave_Global_ECC_P256_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Amazon_Root_CA_3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Security_Communication_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CFCA_EV_ROOT.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:OISTE_WISeKey_Global_Root_GB_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Assured_ID_Root_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Assured_ID_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GDCA_TrustAUTH_R5_ROOT.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Microsoft_ECC_Root_Certificate_Authority_2017.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Baltimore_CyberTrust_Root.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_ECC_Root_CA_-_R4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Secure_Global_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:D-TRUST_EV_Root_CA_1_2020.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SecureSign_RootCA11.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Starfield_Root_Certificate_Authority_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Security_Communication_RootCA2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:certSIGN_Root_CA_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Security_Communication_RootCA3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:BJCA_Global_Root_CA2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:QuoVadis_Root_CA_3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AffirmTrust_Premium.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GTS_Root_R4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SecureTrust_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:HARICA_TLS_ECC_Root_CA_2021.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Hellenic_Academic_and_Research_Institutions_ECC_RootCA_2015.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_TLS_ECC_Root_CA_2022.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Atos_TrustedRoot_2011.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:IdenTrust_Public_Sector_Root_CA_1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TunTrust_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GTS_Root_R3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Hellenic_Academic_and_Research_Institutions_RootCA_2015.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:emSign_ECC_Root_CA_-_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_ECC_Root_CA_-_R5.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SwissSign_Silver_CA_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Microsec_e-Szigno_Root_CA_2009.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Global_Root_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:QuoVadis_Root_CA_2_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Entrust.net_Premium_2048_Secure_Server_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Atos_TrustedRoot_Root_CA_RSA_TLS_2021.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TWCA_Root_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certainly_Root_E1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Buypass_Class_2_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_Root_E46.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Entrust_Root_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Telia_Root_CA_v2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Sectigo_Public_Server_Authentication_Root_E46.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:emSign_Root_CA_-_C1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:e-Szigno_Root_CA_2017.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_High_Assurance_EV_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CommScope_Public_Trust_ECC_Root-02.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_Root_CA_-_R6.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:GlobalSign_Root_R46.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:ACCVRAIZ1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certum_Trusted_Network_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Izenpe.com.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_Root_Certification_Authority_RSA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:NAVER_Global_Root_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SZAFIR_ROOT_CA2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TeliaSonera_Root_CA_v1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Buypass_Class_3_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:D-TRUST_Root_Class_3_CA_2_2009.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Autoridad_de_Certificacion_Firmaprofesional_CIF_A62634068.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:NetLock_Arany_=Class_Gold=_Főtanúsítvány.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TrustAsia_Global_Root_CA_G4.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:CA_Disig_Root_R2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:T-TeleSec_GlobalRoot_Class_3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:QuoVadis_Root_CA_3_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TrustAsia_Global_Root_CA_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Atos_TrustedRoot_Root_CA_ECC_TLS_2021.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:IdenTrust_Commercial_Root_CA_1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AC_RAIZ_FNMT-RCM_SERVIDORES_SEGUROS.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:COMODO_RSA_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:UCA_Extended_Validation_Root.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:DigiCert_Assured_ID_Root_G3.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Entrust_Root_Certification_Authority_-_EC1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:TUBITAK_Kamu_SM_SSL_Kok_Sertifikasi_-_Surum_1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:ePKI_Root_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:vTrus_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Trustwave_Global_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:USERTrust_RSA_Certification_Authority.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certum_Trusted_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certigna.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_EV_Root_Certification_Authority_ECC.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Actalis_Authentication_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:ANF_Secure_Server_Root_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Certum_EC-384_CA.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Amazon_Root_CA_2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:HARICA_TLS_RSA_Root_CA_2021.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Entrust_Root_Certification_Authority_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Go_Daddy_Root_Certificate_Authority_-_G2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_EV_Root_Certification_Authority_RSA_R2.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:SSL.com_TLS_RSA_Root_CA_2022.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:Amazon_Root_CA_1.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AC_RAIZ_FNMT-RCM.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Adding debian:AffirmTrust_Premium_ECC.pem
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": done.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Processing triggers for libc-bin (2.31-0ubuntu9.18) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Processing triggers for ca-certificates (20240203~20.04.1) ...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Updating certificates in /etc/ssl/certs...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 0 added, 0 removed; done.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Running hooks in /etc/ca-certificates/update.d...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": 
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": done.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": done.
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container cc55dc0c5d04
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> aea501b723d3
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 3/12 : RUN git clone --depth 1 https://github.com/google/cel-cpp/
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in 81eae8aefc51
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Cloning into 'cel-cpp'...
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container 81eae8aefc51
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> d192c4af4728
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 4/12 : COPY build.sh $SRC/
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 496558d35e8d
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 5/12 : RUN mkdir $SRC/cel-cpp/fuzz/
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in 3a0e0bae72b7
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container 3a0e0bae72b7
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 8cf699765b4f
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 6/12 : COPY build.sh $SRC/cel-cpp
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 8aa74a23cd55
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 7/12 : COPY BUILD fuzz*.cc $SRC/cel-cpp/fuzz/
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 0bd4cfd89910
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 8/12 : COPY MODULE.bazel .bazelrc $SRC/
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 4becd425be59
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 9/12 : RUN cat MODULE.bazel >> $SRC/cel-cpp/MODULE.bazel
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in 7579058aac95
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container 7579058aac95
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 14fb06423eb0
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 10/12 : RUN cat .bazelrc >> $SRC/cel-cpp/.bazelrc
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in a5929e5f776e
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container a5929e5f776e
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 91573f7b4261
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 11/12 : WORKDIR $SRC/cel-cpp
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in 52dda3b73971
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container 52dda3b73971
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 33331326ae23
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Step 12/12 : ENV OLD_LLVMPASS=1
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> Running in fd1110b387b5
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Removing intermediate container fd1110b387b5
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31":  ---> 8ecf40d6e455
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Successfully built 8ecf40d6e455
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Successfully tagged gcr.io/oss-fuzz/cel-cpp:latest
Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31": Successfully tagged us-central1-docker.pkg.dev/oss-fuzz/unsafe/cel-cpp:latest
Finished Step #1 - "build-0783083b-1c99-4e95-b808-04a3ee6e2b31"
Starting Step #2 - "srcmap"
Step #2 - "srcmap": Already have image: gcr.io/oss-fuzz/cel-cpp
Step #2 - "srcmap": ++ tempfile
Step #2 - "srcmap": + SRCMAP=/tmp/fileKtu1AP
Step #2 - "srcmap": + echo '{}'
Step #2 - "srcmap": + PATHS_TO_SCAN=/src
Step #2 - "srcmap": + [[ c++ == \g\o ]]
Step #2 - "srcmap": ++ find /src -name .git -type d
Step #2 - "srcmap": + for DOT_GIT_DIR in $(find $PATHS_TO_SCAN -name ".git" -type d)
Step #2 - "srcmap": ++ dirname /src/cel-cpp/.git
Step #2 - "srcmap": + GIT_DIR=/src/cel-cpp
Step #2 - "srcmap": + cd /src/cel-cpp
Step #2 - "srcmap": ++ git config --get remote.origin.url
Step #2 - "srcmap": + GIT_URL=https://github.com/google/cel-cpp/
Step #2 - "srcmap": ++ git rev-parse HEAD
Step #2 - "srcmap": + GIT_REV=d2a8a7831b76fb128de4d03254bc8f81dfcf5652
Step #2 - "srcmap": + jq_inplace /tmp/fileKtu1AP '."/src/cel-cpp" = { type: "git", url: "https://github.com/google/cel-cpp/", rev: "d2a8a7831b76fb128de4d03254bc8f81dfcf5652" }'
Step #2 - "srcmap": ++ tempfile
Step #2 - "srcmap": + F=/tmp/fileGR0oHd
Step #2 - "srcmap": + cat /tmp/fileKtu1AP
Step #2 - "srcmap": + jq '."/src/cel-cpp" = { type: "git", url: "https://github.com/google/cel-cpp/", rev: "d2a8a7831b76fb128de4d03254bc8f81dfcf5652" }'
Step #2 - "srcmap": + mv /tmp/fileGR0oHd /tmp/fileKtu1AP
Step #2 - "srcmap": ++ find /src -name .svn -type d
Step #2 - "srcmap": ++ find /src -name .hg -type d
Step #2 - "srcmap": + '[' '' '!=' '' ']'
Step #2 - "srcmap": + cat /tmp/fileKtu1AP
Step #2 - "srcmap": + rm /tmp/fileKtu1AP
Step #2 - "srcmap": {
Step #2 - "srcmap":   "/src/cel-cpp": {
Step #2 - "srcmap":     "type": "git",
Step #2 - "srcmap":     "url": "https://github.com/google/cel-cpp/",
Step #2 - "srcmap":     "rev": "d2a8a7831b76fb128de4d03254bc8f81dfcf5652"
Step #2 - "srcmap":   }
Step #2 - "srcmap": }
Finished Step #2 - "srcmap"
Starting Step #3 - "compile-libfuzzer-coverage-x86_64"
Step #3 - "compile-libfuzzer-coverage-x86_64": Already have image (with digest): gcr.io/cloud-builders/docker
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": vm.mmap_rnd_bits = 28
Step #3 - "compile-libfuzzer-coverage-x86_64": Compiling libFuzzer to /usr/lib/libFuzzingEngine.a...  done.
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": CC=clang
Step #3 - "compile-libfuzzer-coverage-x86_64": CXX=clang++
Step #3 - "compile-libfuzzer-coverage-x86_64": CFLAGS=-O1   -fno-omit-frame-pointer   -gline-tables-only   -Wno-error=incompatible-function-pointer-types   -Wno-error=int-conversion   -Wno-error=deprecated-declarations   -Wno-error=implicit-function-declaration   -Wno-error=implicit-int   -Wno-error=unknown-warning-option   -Wno-error=vla-cxx-extension   -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  -fprofile-instr-generate -fcoverage-mapping -pthread -Wl,--no-as-needed -Wl,-ldl -Wl,-lm -Wno-unused-command-line-argument
Step #3 - "compile-libfuzzer-coverage-x86_64": CXXFLAGS=-O1   -fno-omit-frame-pointer   -gline-tables-only   -Wno-error=incompatible-function-pointer-types   -Wno-error=int-conversion   -Wno-error=deprecated-declarations   -Wno-error=implicit-function-declaration   -Wno-error=implicit-int   -Wno-error=unknown-warning-option   -Wno-error=vla-cxx-extension   -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  -fprofile-instr-generate -fcoverage-mapping -pthread -Wl,--no-as-needed -Wl,-ldl -Wl,-lm -Wno-unused-command-line-argument -stdlib=libc++
Step #3 - "compile-libfuzzer-coverage-x86_64": RUSTFLAGS=--cfg fuzzing -Cdebuginfo=1 -Cforce-frame-pointers -Cinstrument-coverage -C link-arg=-lc++
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": + export USE_BAZEL_VERSION=8.7.0
Step #3 - "compile-libfuzzer-coverage-x86_64": + USE_BAZEL_VERSION=8.7.0
Step #3 - "compile-libfuzzer-coverage-x86_64": + export CC=clang
Step #3 - "compile-libfuzzer-coverage-x86_64": + CC=clang
Step #3 - "compile-libfuzzer-coverage-x86_64": + export CXX=clang++
Step #3 - "compile-libfuzzer-coverage-x86_64": + CXX=clang++
Step #3 - "compile-libfuzzer-coverage-x86_64": + bazel build -c opt --config=oss-fuzz //fuzz:fuzz_parse_oss_fuzz //fuzz:fuzz_eval_oss_fuzz
Step #3 - "compile-libfuzzer-coverage-x86_64": 2026/06/14 06:29:01 Downloading https://releases.bazel.build/8.7.0/release/bazel-8.7.0-linux-x86_64...
Step #3 - "compile-libfuzzer-coverage-x86_64": Extracting Bazel installation...
Step #3 - "compile-libfuzzer-coverage-x86_64": Starting local Bazel server (8.7.0) and connecting to it...
Step #3 - "compile-libfuzzer-coverage-x86_64": Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/modules/platforms/1.0.0/MODULE.bazel
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/modules/rules_java/8.3.2/MODULE.bazel
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/modules/rules_go/0.33.0/MODULE.bazel
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/modules/mbedtls/metadata.json
Step #3 - "compile-libfuzzer-coverage-x86_64": 

WARNING: For repository 'rules_java', the root module requires module version rules_java@8.6.1, but got rules_java@8.14.0 in the resolved dependency graph. Please update the version in your MODULE.bazel or set --check_direct_dependencies=off
Step #3 - "compile-libfuzzer-coverage-x86_64": Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_fuzzing+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_fuzzing+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_fuzzing+; Patching repository
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/...ODULE.bazel; Checking in SHA-256 cache
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@protobuf+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_shell+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_android+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_python+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/.../download/v34.1/protobuf-34.1.bazel.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/.../v0.6.4/rules_android-v0.6.4.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 







Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@protobuf+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_android+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_python+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...f37f/external/protobuf+; Extracting protobuf-34.1.bazel.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...f/external/rules_python+; Extracting rules_python-1.6.3.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...xternal/rules_android+; Extracting rules_android-v0.6.4.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_java++compatibility_proxy+compatibility_proxy; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 







Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@protobuf+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_python+; Patching repository
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...f37f/external/protobuf+; Extracting protobuf-34.1.bazel.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_cc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@bazel_features+; Patching repository
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/.../download/0.2.14/rules_cc-0.2.14.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Computing main repo mapping: 
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@protobuf+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...f37f/external/protobuf+; Extracting protobuf-34.1.bazel.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Loading: 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Loading: 1 packages loaded
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Analyzing: 2 targets (2 packages loaded)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Analyzing: 2 targets (2 packages loaded, 0 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Analyzing: 2 targets (2 packages loaded, 0 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Analyzing: 2 targets (6 packages loaded, 6 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/engines
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (56 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@@rules_python+//python/extensions:python.bzl%python; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_kotlin+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@apple_support+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_nodejs+; Patching repository
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_go+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@bazel_lib+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@aspect_bazel_lib+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ... @@rules_java++toolchains+local_jdk; starting ... (11 fetches)
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (65 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools ... (9 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_kotlin+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_go+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@aspect_rules_js+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/.../download/v2.2.2/rules_kotlin-v2.2.2.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...800270f37f/external/rules_go+; Extracting rules_go-v0.53.0.zip
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...nsion @@rules_python+//python/extensions:pip.bzl%pip; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...f/external/aspect_rules_js+; Extracting rules_js-v2.3.8.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...azel_lib++toolchains+bats_toolchains; starting ... (9 fetches)
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (74 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_kotlin+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_go+; Patching repository
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/...ules_kotlin-v2.2.2.tar.gz; 33.7 MiB (69.6%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@bazel_lib++toolchains+bats_toolchains; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...itory @@aspect_bazel_lib++toolchains+bats_toolchains; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/bats-core/bats-core/archive/v1.10.0.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://pypi.org/simple/pkginfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (77 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_kotlin+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../external/rules_kotlin+; Extracting rules_kotlin-v2.2.2.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (77 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_kotlin+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../external/rules_kotlin+; Extracting rules_kotlin-v2.2.2.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 





Analyzing: 2 targets (77 packages loaded, 9 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools ... (2 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/...bd94df4bd9f9362d16b76f34e4c7c2358409.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...epositories:bzlmod_setup.bzl%rules_kotlin_extensions; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 





Analyzing: 2 targets (99 packages loaded, 1144 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools ... (3 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/...6b76f34e4c7c2358409.tar.gz; 7.0 MiB (41.7%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (102 packages loaded, 2824 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...y @@rules_cc++cc_configure_extension+local_config_cc; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../grpc+; Extracting b73dbd94df4bd9f9362d16b76f34e4c7c2358409.ta\
Step #3 - "compile-libfuzzer-coverage-x86_64": r.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (102 packages loaded, 2824 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...y @@rules_cc++cc_configure_extension+local_config_cc; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../grpc+; Extracting b73dbd94df4bd9f9362d16b76f34e4c7c2358409.ta\
Step #3 - "compile-libfuzzer-coverage-x86_64": r.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (102 packages loaded, 2824 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...y @@rules_cc++cc_configure_extension+local_config_cc; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../grpc+; Extracting b73dbd94df4bd9f9362d16b76f34e4c7c2358409.ta\
Step #3 - "compile-libfuzzer-coverage-x86_64": r.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (102 packages loaded, 2824 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@grpc+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...y @@rules_cc++cc_configure_extension+local_config_cc; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching .../grpc+; Extracting b73dbd94df4bd9f9362d16b76f34e4c7c2358409.ta\
Step #3 - "compile-libfuzzer-coverage-x86_64": r.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (109 packages loaded, 2862 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...on/extensions:pip.bzl%pip; Fetch package lists from PyPI index
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@protoc-gen-validate+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (109 packages loaded, 2862 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_fuzzing+//fuzzing/tools
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_python++pip+rules_fuzzing_py_deps; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (115 packages loaded, 5667 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._python++python+python_3_11_x86_64-unknown-linux-gnu; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...3_11_host; Symlinking interpreter files to the target platform
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/...86_64-unknown-linux-gnu-install_only.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (115 packages loaded, 5667 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._python++python+python_3_11_x86_64-unknown-linux-gnu; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...3_11_host; Symlinking interpreter files to the target platform
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://github.com/...x-gnu-install_only.tar.gz; 24.4 MiB (55.4%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (115 packages loaded, 5667 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._python++python+python_3_11_x86_64-unknown-linux-gnu; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...3_11_host; Symlinking interpreter files to the target platform
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...ux-gnu; Extracting cpython-3.11.13_20250808-x86_64-unknown-lin\
Step #3 - "compile-libfuzzer-coverage-x86_64": ux-gnu-install_only.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 





Analyzing: 2 targets (115 packages loaded, 5667 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._python++python+python_3_11_x86_64-unknown-linux-gnu; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...3_11_host; Symlinking interpreter files to the target platform
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...ux-gnu; Extracting cpython-3.11.13_20250808-x86_64-unknown-lin\
Step #3 - "compile-libfuzzer-coverage-x86_64": ux-gnu-install_only.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 





Analyzing: 2 targets (115 packages loaded, 5667 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._python++python+python_3_11_x86_64-unknown-linux-gnu; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...3_11_host; Symlinking interpreter files to the target platform
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (117 packages loaded, 7924 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_python+//python/private
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_python++internal_deps+pypi__installer; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...pi__installer; Extracting installer-0.7.0-py3-none-any.whl.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64": 

Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...@rules_python++pip+rules_fuzzing_py_deps_311_absl_py; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_python++internal_deps+pypi__wheel; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://files.pythonhosted.org/.../wheel-0.43.0-py3-none-any.whl
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...bsl_py; Running whl_library.ResolveRequirement(rules_python++p\
Step #3 - "compile-libfuzzer-coverage-x86_64": ip+rules_fuzzing_py_deps_311_absl_py, absl-py==2.0.0)
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...bsl_py; Running whl_library.ResolveRequirement(rules_python++p\
Step #3 - "compile-libfuzzer-coverage-x86_64": ip+rules_fuzzing_py_deps_311_absl_py, absl-py==2.0.0) 4s
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...bsl_py; Running whl_library.ResolveRequirement(rules_python++p\
Step #3 - "compile-libfuzzer-coverage-x86_64": ip+rules_fuzzing_py_deps_311_absl_py, absl-py==2.0.0) 5s
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...bsl_py; Running whl_library.ExtractWheel(rules_python++pip+rul\
Step #3 - "compile-libfuzzer-coverage-x86_64": es_fuzzing_py_deps_311_absl_py, /root/.cache/bazel/_bazel_root/9237247786220da\
Step #3 - "compile-libfuzzer-coverage-x86_64": c906b18800270f37f/external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py\
Step #3 - "compile-libfuzzer-coverage-x86_64": /absl_py-2.0.0-py3-none-any.whl) 5s
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (118 packages loaded, 7938 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_python++pip+rules_fuzzing_py_deps_311_absl_py//
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (138 packages loaded, 10921 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@protobuf+//src/google/protobuf ... (4 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@abseil-cpp+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@cel-spec+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@antlr4-cpp-runtime+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_pkg+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@+_repo_rules+antlr4_jar; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...+toolchains+remote_java_tools_linux; starting ... (10 fetches)
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (143 packages loaded, 14000 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@protobuf+//src/google/protobuf ... (3 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@abseil-cpp+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@cel-spec+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@antlr4-cpp-runtime+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_pkg+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@+_repo_rules+antlr4_jar; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...+toolchains+remote_java_tools_linux; starting ... (17 fetches)
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (185 packages loaded, 14768 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@cel-spec+//proto/cel/expr
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@abseil-cpp+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@antlr4-cpp-runtime+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...ory @@rules_java++toolchains+remote_java_tools_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://mirror.bazel.build/...a_tools-v16.0.zip; 13.2 MiB (31.3%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/....tar.gz; 11.9 MiB (6.2%) ... (15 fetches)
Step #3 - "compile-libfuzzer-coverage-x86_64": 









Analyzing: 2 targets (209 packages loaded, 15249 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@abseil-cpp+//absl/crc ... (2 packages)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@antlr4-cpp-runtime+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.26-linux_x64.tar.gz; 25.3 MiB (13.2%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...k21.0.6-linux_x64.tar.gz; 13.2 MiB (6.5%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 







Analyzing: 2 targets (211 packages loaded, 15596 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@antlr4-cpp-runtime+; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.26-linux_x64.tar.gz; 39.2 MiB (20.5%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...21.0.6-linux_x64.tar.gz; 31.8 MiB (15.6%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...+toolchains+remote_java_tools; Extracting java_tools-v16.0.zip
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://bcr.bazel.build/.../BUILD; Checking in SHA-256 cache
Step #3 - "compile-libfuzzer-coverage-x86_64": 








Analyzing: 2 targets (212 packages loaded, 16138 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.26-linux_x64.tar.gz; 55.8 MiB (29.1%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...21.0.6-linux_x64.tar.gz; 71.1 MiB (34.9%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...+toolchains+remote_java_tools; Extracting java_tools-v16.0.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (212 packages loaded, 16287 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remote_java_tools; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.26-linux_x64.tar.gz; 92.4 MiB (48.2%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...21.0.6-linux_x64.tar.gz; 89.5 MiB (43.9%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...+toolchains+remote_java_tools; Extracting java_tools-v16.0.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": 






Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/....0.26-linux_x64.tar.gz; 110.5 MiB (57.7%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.6-linux_x64.tar.gz; 106.7 MiB (52.4%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/....0.26-linux_x64.tar.gz; 128.5 MiB (67.1%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.6-linux_x64.tar.gz; 141.0 MiB (69.3%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/....0.26-linux_x64.tar.gz; 162.6 MiB (84.9%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.6-linux_x64.tar.gz; 158.2 MiB (77.7%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/....0.26-linux_x64.tar.gz; 181.0 MiB (94.5%)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.6-linux_x64.tar.gz; 175.4 MiB (86.1%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching https://cdn.azul.com/...1.0.6-linux_x64.tar.gz; 192.4 MiB (94.5%)
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._linux; Extracting zulu11.78.15-ca-jdk11.0.26-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 



Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk11_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching repository @@rules_java++toolchains+remotejdk21_linux; starting
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._linux; Extracting zulu11.78.15-ca-jdk11.0.26-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...1_linux; Extracting zulu21.40.17-ca-jdk21.0.6-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_java++toolchains+remotejdk11_linux; starting 4s
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_java++toolchains+remotejdk21_linux; starting 4s
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._linux; Extracting zulu11.78.15-ca-jdk11.0.26-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...1_linux; Extracting zulu21.40.17-ca-jdk21.0.6-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (213 packages loaded, 16295 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_java++toolchains+remotejdk11_linux; starting 5s
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_java++toolchains+remotejdk21_linux; starting 5s
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ..._linux; Extracting zulu11.78.15-ca-jdk11.0.26-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...1_linux; Extracting zulu21.40.17-ca-jdk21.0.6-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 




Analyzing: 2 targets (214 packages loaded, 16416 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...sitory @@rules_java++toolchains+remotejdk21_linux; starting 5s
Step #3 - "compile-libfuzzer-coverage-x86_64":     Fetching ...1_linux; Extracting zulu21.40.17-ca-jdk21.0.6-linux_x64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64": 


Analyzing: 2 targets (214 packages loaded, 16416 targets configured)
Step #3 - "compile-libfuzzer-coverage-x86_64":     currently loading: @@rules_java++toolchains+remotejdk21_linux//
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 


INFO: Analyzed 2 targets (215 packages loaded, 16550 targets configured).
Step #3 - "compile-libfuzzer-coverage-x86_64": [37 / 477] 7 actions, 5 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/container:flat_hash_map; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     [Prepa] @rules_fuzzing//fuzzing/tools:make_corpus_dir
Step #3 - "compile-libfuzzer-coverage-x86_64":     [Prepa] @com_google_protobuf//src/google/protobuf/stubs:lite
Step #3 - "compile-libfuzzer-coverage-x86_64":     [Prepa] Creating source manifest for //bazel:antlr4_tool [for tool]
Step #3 - "compile-libfuzzer-coverage-x86_64":     [Prepa] @com_google_protobuf//src/google/protobuf:port
Step #3 - "compile-libfuzzer-coverage-x86_64":     [Prepa] @com_google_protobuf//src/google/protobuf/stubs:lite
Step #3 - "compile-libfuzzer-coverage-x86_64": 






[285 / 1,293] 18 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/spinlock_wait.cc [for tool]; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[507 / 1,720] 27 actions, 26 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/spinlock_wait.cc [for tool]; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[583 / 1,835] 30 actions, 28 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/spinlock_wait.cc [for tool]; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[685 / 1,896] 30 actions, 29 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[686 / 1,896] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[687 / 1,898] 31 actions, 30 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[697 / 1,898] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_if.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[698 / 1,898] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/log_severity.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/throw_delegate.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/raw_logging.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[752 / 1,950] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/civil_time_detail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_lookup.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_fixed.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/container:hashtablez_sampler; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[874 / 2,063] 32 actions, 30 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_fixed.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/container:hashtablez_sampler; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/globals.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[888 / 2,063] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_impl.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_libc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/usage_config.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[904 / 2,063] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_format.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/usage_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_navigator.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_consume.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[906 / 2,063] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_format.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/usage_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_navigator.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_consume.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/futex_waiter.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[910 / 2,063] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_navigator.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_consume.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/debugging/symbolize.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/program_name.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arena.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[918 / 2,063] 31 actions, 30 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_consume.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/debugging/symbolize.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arena.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[949 / 2,067] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arena.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/cpu_detect.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/sem_waiter.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/arena.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena.cc:703:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   703 |   absl::MutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [951 / 2,067] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arena.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/cpu_detect.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/sem_waiter.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[955 / 2,068] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/cpu_detect.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/sem_waiter.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[959 / 2,068] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/sem_waiter.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc [for tool]; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[960 / 2,068] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/internal/cctz/src/time_zone_info.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_reader.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[962 / 2,068] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_reader.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[980 / 2,080] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_reader.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[981 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/marshalling.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_reader.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[983 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree_reader.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_internal.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[997 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,002 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,009 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_info.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_internal.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,016 / 2,080] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord_analysis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_internal.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @rules_java//toolchains:platformclasspath; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/port.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,026 / 2,083] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @rules_java//toolchains:platformclasspath; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/log_entry.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,031 / 2,083] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @rules_java//toolchains:platformclasspath; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/log_entry.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,034 / 2,083] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @rules_java//toolchains:platformclasspath; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/log_entry.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,036 / 2,083] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @rules_java//toolchains:platformclasspath; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,039 / 2,083] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/log_sink.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,045 / 2,083] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,048 / 2,083] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/str_format/float_conversion.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/mutex.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,061 / 2,091] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_trail.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/mutex.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,083 / 2,103] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/mutex.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_sink.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,104 / 2,103] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/container/internal/raw_hash_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/mutex.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/duration.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,108 / 2,104] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/mutex.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/duration.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/gzip_stream.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,111 / 2,104] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/duration.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/numbers.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/gzip_stream.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,116 / 2,106] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/duration.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/gzip_stream.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_handle.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,117 / 2,106] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/gzip_stream.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cordz_handle.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,124 / 2,106] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/gzip_stream.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/numeric/int128.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/check_op.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,129 / 2,106] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/numeric/int128.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/check_op.cc [for tool]; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/pthread_waiter.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/typeinfo.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,135 / 2,106] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/check_op.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/pthread_waiter.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/stdcpp_waiter.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/pattern/TextChunk.cpp; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,138 / 2,106] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/stdcpp_waiter.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/pattern/TextChunk.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/time.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,140 / 2,106] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/pattern/TextChunk.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/time.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../io/zero_copy_stream_impl.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,149 / 2,107] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/time.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_crc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/graphcycles.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,157 / 2,108] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_crc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/graphcycles.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     //parser/internal:cel_grammar; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,164 / 2,108] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_crc.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/synchronization/internal/graphcycles.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     //parser/internal:cel_grammar; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,171 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/strtod.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,177 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,179 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,182 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/strings:str_format_internal; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,198 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/strings:str_format_internal; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,203 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/strings:str_format_internal; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,205 / 2,108] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_non_temporal_memcpy.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_ptr_field.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/strings:str_format_internal; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,208 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_absl//absl/strings:str_format_internal; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/coded_stream.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,210 / 2,108] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/reflection.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/coded_stream.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,216 / 2,109] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/zero_copy_stream.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/charconv.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/debugging/internal/demangle.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,221 / 2,110] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/errors.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/implicit_weak_message.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,222 / 2,110] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/attribute.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/errors.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/implicit_weak_message.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,224 / 2,110] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/errors.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/implicit_weak_message.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/internal/unknown_set.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,230 / 2,111] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/implicit_weak_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/internal/unknown_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/usage.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,239 / 2,111] 31 actions, 30 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/function_result_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/implicit_weak_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/internal/unknown_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,241 / 2,111] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/internal/unknown_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @antlr4-cpp-runtime//:antlr4-cpp-runtime; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,245 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling base/internal/unknown_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @antlr4-cpp-runtime//:antlr4-cpp-runtime; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,248 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelVisitor.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @antlr4-cpp-runtime//:antlr4-cpp-runtime; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/globals.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,257 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/charconv_bigint.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,260 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_field.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/vlog_config.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/charconv_bigint.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,293 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/repeated_field.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/charconv_bigint.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,297 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/charconv_bigint.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,301 / 2,112] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling bazel/cel_cc_embed.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,305 / 2,112] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/civil_time.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,314 / 2,118] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/civil_time.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/arenastring.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenastring.cc:60:6: warning: 'Lock' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |   mu.Lock();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:181:3: note: 'Lock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   181 |   ABSL_DEPRECATE_AND_INLINE()
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/macros.h:229:39: note: expanded from macro 'ABSL_DEPRECATE_AND_INLINE'
Step #3 - "compile-libfuzzer-coverage-x86_64":   229 | #define ABSL_DEPRECATE_AND_INLINE() [[deprecated]] ABSL_REFACTOR_INLINE
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenastring.cc:68:6: warning: 'Unlock' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |   mu.Unlock();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:190:3: note: 'Unlock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   190 |   ABSL_DEPRECATE_AND_INLINE()
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/macros.h:229:39: note: expanded from macro 'ABSL_DEPRECATE_AND_INLINE'
Step #3 - "compile-libfuzzer-coverage-x86_64":   229 | #define ABSL_DEPRECATE_AND_INLINE() [[deprecated]] ABSL_REFACTOR_INLINE
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 2 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,318 / 2,118] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/arenastring.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/statusor.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/time/civil_time.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,322 / 2,118] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/parse.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/unknown_function_result_set.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,329 / 2,121] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/log/internal/log_message.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/unknown_function_result_set.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/substitute.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,334 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/internal/status_internal.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/unknown_function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/substitute.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,337 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf_lite; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/stubs/common.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/unknown_function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/substitute.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/status/status_payload_printer.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathTokenElement.cpp; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,346 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/unknown_function_result_set.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/flag.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/base/internal/thread_identity.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,350 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/flag.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,352 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/flag.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,353 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/flags/internal/flag.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,356 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/escaping.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,359 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/rust_field_type.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelBaseVisitor.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/escaping.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,366 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/escaping.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,369 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/escaping.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,379 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_enum_util.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,382 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_enum_util.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,384 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_enum_util.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,387 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/internal/cord_rep_btree.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,390 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,392 / 2,122] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,393 / 2,122] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/strings/cord.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,400 / 2,126] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/parse_context.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,402 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/java_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/csharp/names.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,408 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/tostring.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/utf8.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,410 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/utf8.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/importer.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,413 / 2,126] 31 actions, 30 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/utf8.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,415 / 2,126] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/retention.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/lexis.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/utf8.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,418 / 2,126] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/utf8.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/inlined_string_field.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,421 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,427 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/any.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,429 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,432 / 2,126] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,432 / 2,126] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,438 / 2,129] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,439 / 2,129] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,444 / 2,130] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/internal/CelParser.cpp; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/unknown_field_set.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,448 / 2,130] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/unknown_field_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,452 / 2,130] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/unknown_field_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/strings.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,455 / 2,131] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/unknown_field_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/strings.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,466 / 2,134] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/unknown_field_set.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/strings.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,469 / 2,134] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,474 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/source.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": common/source.cc:119:44: warning: implicit conversion from 'const char16_t' to 'char32_t' may change the meaning of the represented code unit [-Wcharacter-conversion]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |               internal::Utf8Encode(result, code_point);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ~~~~~~~~                     ^~~~~~~~~~
Step #3 - "compile-libfuzzer-coverage-x86_64": common/source.cc:150:50: warning: implicit conversion from 'const char16_t' to 'char32_t' may change the meaning of the represented code unit [-Wcharacter-conversion]
Step #3 - "compile-libfuzzer-coverage-x86_64":   150 |                       internal::Utf8Encode(dest, code_point);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ~~~~~~~~                   ^~~~~~~~~~
Step #3 - "compile-libfuzzer-coverage-x86_64": 2 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,475 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/message_lite.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_lite.cc:787:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   787 |   absl::MutexLock lock(&shutdown_data->mutex);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,475 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/source.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,480 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,481 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/plugin.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling absl/crc/internal/crc_cord_state.cc [for tool]; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,483 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/micro_string.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,485 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/micro_string.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,490 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/BailErrorStrategy.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,493 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/BailErrorStrategy.cpp; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,495 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/set.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,498 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/set.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,500 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/set.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,504 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/set.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,509 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../json/internal/zero_copy_buffered_stream.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,514 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/filtered_re2.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/BufferedTokenStream.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,519 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/filtered_re2.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,522 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,522 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,523 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/compile.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/dynamic_message.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/dynamic_message.cc:837:27: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   837 |         !field->options().weak() && !InRealOneof(field) &&
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/dynamic_message.cc:872:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   872 |   absl::MutexLock lock(&prototypes_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 2 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,524 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/dynamic_message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/file_layout.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,529 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_traverse.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/file_layout.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,531 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/file_layout.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/extension_set_heavy.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,531 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/file_layout.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/extension_set_heavy.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,532 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/file_layout.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/extension_set_heavy.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,535 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,538 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,539 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPathLexer.cpp; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,542 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,562 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,564 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/dfa.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,569 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/constant.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,571 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/tokenizer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,573 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,574 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/DefaultErrorStrategy.cpp; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,576 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/parse.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,578 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/parse.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,581 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_bases.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_rewrite.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,584 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/regexp.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/expr.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_rewrite.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/FailedPredicateException.cpp; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,587 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_rewrite.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/FailedPredicateException.cpp; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/names.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,590 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_rewrite.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,591 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl_lite.cc; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,592 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl_lite.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,592 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl_lite.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,593 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl_lite.cc; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,595 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/io/zero_copy_stream_impl_lite.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,598 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,598 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/text_format.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/text_format.cc:664:50: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   664 |       if (consumed_semicolon && field->options().weak() &&
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/text_format.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/text_format.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2685:29: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2685 |       absl::ReaderMutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/text_format.cc:3046:23: note: in instantiation of function template specialization 'google::protobuf::DescriptorPool::MemoizeProjection<google::protobuf::FieldDescriptor, (lambda at external/protobuf+/src/google/protobuf/text_format.cc:3047:18)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":  3046 |       DescriptorPool::MemoizeProjection(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/text_format.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/text_format.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2694:23: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2694 |       absl::MutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 3 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,599 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,602 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_expr_factory.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,605 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/code_generator_lite.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_expr_factory.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,607 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_expr_factory.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,609 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling re2/prefilter_tree.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_expr_factory.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,612 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPath.cpp; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,613 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/tree/xpath/XPath.cpp; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,615 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,616 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,617 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/internal_feature_helper.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/generated_message_tctable_gen.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.cc:669:41: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   669 |     if (descriptor->field(i)->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.cc:708:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 |       field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.cc:743:50: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   743 |            !field->is_map() && !field->options().weak() &&
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.cc:783:35: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   783 |       } else if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 4 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,618 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,619 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/map_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field.cc:268:21: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   268 |     absl::MutexLock lock(&p->mutex());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field.cc:318:23: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   318 |       absl::MutexLock lock(&p->mutex());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field.cc:427:23: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   427 |       absl::MutexLock lock(&p.mutex());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 3 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,619 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,621 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,623 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/io/printer.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,624 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,625 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/minitable/main.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,627 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,627 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,629 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,631 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/metadata.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,635 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/symbol_checker.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,636 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/symbol_checker.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,639 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/check_ast_extensions.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/symbol_checker.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,641 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/symbol_checker.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/message.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/message.cc:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:109:35: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     ABSL_DCHECK(!field->options().weak()) << "weak fields are not supported";
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message.cc:382:29: warning: 'WriterMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   382 |       absl::WriterMutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:703:5: note: 'WriterMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   703 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message.cc:397:27: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   397 |     absl::ReaderMutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message.cc:419:27: warning: 'WriterMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   419 |     absl::WriterMutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:703:5: note: 'WriterMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   703 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 4 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,642 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,644 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,644 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,645 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/plugin.pb.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,646 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/plugin.pb.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,646 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/importer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/cpp_features.pb.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/plugin.pb.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,649 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/plugin.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_lite.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,652 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/plugin.pb.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_lite.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,653 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/plugin.pb.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_lite.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,657 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,658 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,660 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,661 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,663 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,665 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling upb_generator/c/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,666 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,667 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,670 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,670 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,674 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/generated_message_reflection.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/generated_message_reflection.cc:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:109:35: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     ABSL_DCHECK(!field->options().weak()) << "weak fields are not supported";
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:2469:51: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2469 |   if (!field->is_extension() && !field->options().weak() &&
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3180:33: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3180 |   ABSL_DCHECK(!field->options().weak());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3213:33: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3213 |   ABSL_DCHECK(!field->options().weak());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3222:33: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3222 |   ABSL_DCHECK(!field->options().weak());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3231:33: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3231 |   ABSL_DCHECK(!field->options().weak());
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/generated_message_reflection.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_reflection.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2685:29: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2685 |       absl::ReaderMutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3647:29: note: in instantiation of function template specialization 'google::protobuf::DescriptorPool::MemoizeProjection<google::protobuf::EnumDescriptor, (lambda at external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3649:17)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":  3647 |             DescriptorPool::MemoizeProjection(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/generated_message_reflection.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_reflection.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2694:23: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2694 |       absl::MutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3882:8: warning: 'Lock' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3882 |     mu.Lock();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:181:3: note: 'Lock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   181 |   ABSL_DEPRECATE_AND_INLINE()
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/macros.h:229:39: note: expanded from macro 'ABSL_DEPRECATE_AND_INLINE'
Step #3 - "compile-libfuzzer-coverage-x86_64":   229 | #define ABSL_DEPRECATE_AND_INLINE() [[deprecated]] ABSL_REFACTOR_INLINE
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:3884:8: warning: 'Unlock' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3884 |     mu.Unlock();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:190:3: note: 'Unlock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   190 |   ABSL_DEPRECATE_AND_INLINE()
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/macros.h:229:39: note: expanded from macro 'ABSL_DEPRECATE_AND_INLINE'
Step #3 - "compile-libfuzzer-coverage-x86_64":   229 | #define ABSL_DEPRECATE_AND_INLINE() [[deprecated]] ABSL_REFACTOR_INLINE
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/generated_message_reflection.cc:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:109:35: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     ABSL_DCHECK(!field->options().weak()) << "weak fields are not supported";
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:447:20: note: in instantiation of function template specialization 'google::protobuf::internal::ReflectionVisit::VisitFields<google::protobuf::Message, (lambda at bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:449:7)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":   447 |   ReflectionVisit::VisitFields(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h:502:20: note: in instantiation of function template specialization 'google::protobuf::internal::ReflectionVisit::VisitMessageFields<(lambda at external/protobuf+/src/google/protobuf/generated_message_reflection.cc:1344:48)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":   502 |   ReflectionVisit::VisitMessageFields(message, std::forward<CallbackFn>(func));
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc:1344:15: note: in instantiation of function template specialization 'google::protobuf::internal::VisitMutableMessageFields<(lambda at external/protobuf+/src/google/protobuf/generated_message_reflection.cc:1344:48)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":  1344 |     internal::VisitMutableMessageFields(*curr, [&](Message& msg) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 11 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,676 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:protobuf; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,677 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,678 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,679 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,680 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,681 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/tracker.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/tracker.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,681 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 29s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/tracker.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,684 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 29s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/enum.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,687 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 29s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/enum.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,689 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/enum.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,692 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/enum.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,693 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/enum.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,695 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,696 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,699 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,699 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/extension_set_heavy.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,701 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,704 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,706 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,707 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,708 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,709 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_lite.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/descriptor.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:1980:27: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1980 |     absl::ReaderMutexLock lock(pool->mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:2137:27: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2137 |     absl::ReaderMutexLock l(&unknown_enum_values_mu_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:2146:27: warning: 'WriterMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2146 |     absl::WriterMutexLock l(&unknown_enum_values_mu_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:703:5: note: 'WriterMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   703 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:2647:27: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2647 |     absl::ReaderMutexLock lock(mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:7977:61: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  7977 |     bool is_weak = !pool_->enforce_weak_ && proto.options().weak();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:10592:58: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  10592 |   if (field->real_containing_oneof() || field->options().weak() ||
Step #3 - "compile-libfuzzer-coverage-x86_64":        |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:3632:22: warning: private field 'options_' is not used [-Wunused-private-field]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3632 |   DebugStringOptions options_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 7 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,711 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc [for tool]; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/helpers.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/helpers.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/helpers.cc:1789:28: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1789 |       if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/helpers.cc:2052:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2052 |   absl::MutexLock lock(&bootstrap_cache.mutex);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 3 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,712 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/helpers.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,713 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,715 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,717 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/enum.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,719 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/enum.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,720 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/service.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/python/pyi_generator.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/pyi_generator.cc:609:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   609 |   absl::MutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,721 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/python/pyi_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/service.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,723 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.pb.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,725 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,726 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,728 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,728 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,729 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,730 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,730 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/names.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,734 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/names.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/service.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,735 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/service.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,736 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_reflection.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,737 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_reflection.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/extension.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/extension.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/extension.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,737 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/extension.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_reflection.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,741 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/context.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/src/atn/ParserATNSimulator.cpp; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,743 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/rbs_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,744 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/rbs_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,746 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/rbs_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,749 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,751 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/field_chunk.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,752 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor_database.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/field_chunk.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,753 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/feature_resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/helpers.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,754 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_gen.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,755 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_gen.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,757 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/ruby/ruby_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/generated_message_tctable_gen.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,759 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/internal_feature_helper.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,761 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/internal_feature_helper.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_wrapper_field.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,764 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/internal_feature_helper.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_wrapper_field.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,766 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,769 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_chunk.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_chunk.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field_chunk.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,769 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/field_chunk.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,771 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/name_resolver.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,772 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/ruby/rbs_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/name_resolver.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,773 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,774 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_tctable_gen.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,775 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_wrapper_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,777 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/crate_mapping.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,780 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/crate_mapping.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,782 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 26s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/crate_mapping.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/java/name_resolver.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/java/name_resolver.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/compiler/java/java_features.pb.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_bases.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/message.h:113:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2685:29: warning: 'ReaderMutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2685 |       absl::ReaderMutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/name_resolver.cc:140:28: note: in instantiation of function template specialization 'google::protobuf::DescriptorPool::MemoizeProjection<google::protobuf::FileDescriptor, bool (*)(const google::protobuf::FileDescriptor *)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":   140 |     return DescriptorPool::MemoizeProjection(descriptor, func);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/name_resolver.cc:152:29: note: in instantiation of function template specialization 'google::protobuf::compiler::java::MemoizeProjection::operator()<google::protobuf::FileDescriptor, bool (*)(const google::protobuf::FileDescriptor *)>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":   152 |   return MemoizeProjection()(file, ComputeNeedsOuterClassSuffix);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:663:5: note: 'ReaderMutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/java/name_resolver.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/compiler/java/java_features.pb.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_bases.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/message.h:113:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h:2694:23: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2694 |       absl::MutexLock lock(&pool->field_memo_table_mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 2 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,784 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/name_resolver.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/crate_mapping.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,786 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/crate_mapping.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,788 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_comparator.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,790 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 27s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/php/php_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,792 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/php/php_generator.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,792 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/php/php_generator.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/cord_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/cord_field.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,792 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/cord_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/map_field.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/php/php_generator.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,794 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 28s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/enum_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/enum_field.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,794 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 29s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/enum_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/reflection_ops.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,798 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,798 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 30s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/names.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,798 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/command_line_interface.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/names.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,803 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,807 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 31s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,808 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/parse_function_generator.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/parse_function_generator.cc:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/parse_function_generator.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,808 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/parse_function_generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,810 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/naming.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,815 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/naming.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,815 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 32s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/naming.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,816 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/names.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/naming.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,817 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/naming.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,818 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/naming.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/naming.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/naming.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,818 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 33s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/naming.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,819 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 34s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/field_common.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,821 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 34s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/php/php_generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/field_common.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/map_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/map_field.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,822 / 2,136] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 34s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/field_common.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,825 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 34s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/generated_message_reflection.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/message.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/field_common.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,827 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 35s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/field_common.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,829 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 35s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/field_common.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/helpers.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,832 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 35s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/enum_field.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/primitive_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/primitive_field.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,833 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 35s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/enum_field.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,834 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 36s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/message_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,838 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 36s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/string_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/string_field.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,839 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 36s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../cpp/field_generators/string_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/message_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/message_field.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,840 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 36s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/file.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,846 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 37s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_field_base.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,848 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 37s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_field_base.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,850 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 37s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_field_base.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/python/generator.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/generator.cc:240:19: warning: 'MutexLock' is deprecated: Use the constructor that takes a reference instead [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   240 |   absl::MutexLock lock(&mutex_);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h:620:5: note: 'MutexLock' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":   620 |   [[deprecated("Use the constructor that takes a reference instead")]]
Step #3 - "compile-libfuzzer-coverage-x86_64":       |     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,851 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 37s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/python/generator.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_field_base.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,852 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 37s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     ...//src/google/protobuf/compiler/csharp:csharp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,853 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 38s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     ...//src/google/protobuf/compiler/csharp:csharp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/field_generators/string_view_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/string_view_field.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,853 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 38s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/cpp:cpp; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     ...//src/google/protobuf/compiler/csharp:csharp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,854 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 38s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/wire_format.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/csharp:csharp; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,855 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 38s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/csharp:csharp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,856 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 39s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/csharp:csharp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,856 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 39s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_field_base.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf/compiler/csharp:csharp; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,858 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 39s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,859 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 39s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,860 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 40s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,860 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 40s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,861 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 40s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/text_format.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_map_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,862 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 41s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/file.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,863 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 41s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/enum.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,864 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 42s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../java/message_serialization.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,866 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 42s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,867 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 42s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,868 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 43s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,868 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 43s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,869 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 44s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/message_differencer.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/generator.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,871 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 44s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/rust/enum.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/generator.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/generator.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/file.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/extension.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,872 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 44s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,875 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 45s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/oneof.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,876 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 45s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/oneof.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/with_presence.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/with_presence.cc:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,876 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 45s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/oneof.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/oneof.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/oneof.cc:16:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,877 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 45s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/oneof.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/message_layout_helper.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/message_layout_helper.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/message_layout_helper.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,878 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 45s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/cpp/message_layout_helper.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/string_field.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,882 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 46s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/internal_helpers.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_message_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_message_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,883 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 46s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/string_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_primitive_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,884 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 47s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/string_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_reflection_class.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,885 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 47s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/file.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/csharp/csharp_message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_reflection_class.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/helpers.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,887 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 47s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_reflection_class.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     ...//src/google/protobuf/compiler/csharp:csharp; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,888 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 47s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_reflection_class.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/helpers.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_enum_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,889 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 48s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../objectivec/import_writer.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,889 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 48s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../objectivec/import_writer.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,890 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 48s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/helpers.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../csharp/csharp_repeated_enum_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/rust/accessors/map.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,892 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 49s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/accessors/map.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/file.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/file.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/extension.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,892 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 49s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/cpp/file.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/accessors/map.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,893 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 50s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/accessors/map.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/map.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/map.cc:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,893 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 50s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/accessors/map.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,894 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 50s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/enum_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../java/full/primitive_field.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,895 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 51s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,895 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 51s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/descriptor.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc:3632:22: warning: private field 'options_' is not used [-Wunused-private-field]
Step #3 - "compile-libfuzzer-coverage-x86_64":  3632 |   DebugStringOptions options_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,895 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/descriptor.cc; 51s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/map_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,897 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/map_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/oneof.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,898 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/oneof.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_string.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,900 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/oneof.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_string.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,900 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/oneof.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_string.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/singular_string.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_string.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,900 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/oneof.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_string.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,902 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_scalar.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/singular_scalar.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_scalar.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,902 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_scalar.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,903 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_message.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/message.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/message.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,903 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_message.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/singular_message.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_message.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,903 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_message.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/singular_cord.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_cord.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,905 / 2,136] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/string_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/enum.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/singular_cord.cc [for tool]; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,908 / 2,136] 28 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/primitive_field.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/extension.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/repeated_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,910 / 2,136] 26 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/objectivec/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/repeated_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_builder.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../java/shared_code_generator.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling src/google/protobuf/compiler/rust/accessors/repeated_field.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/rust/accessors/repeated_field.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,910 / 2,136] 26 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../rust/accessors/repeated_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_builder.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../java/shared_code_generator.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,914 / 2,136] 22 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/rust/generator.cc [for tool]; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_builder.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,915 / 2,136] 21 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_builder.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/file.cc [for tool]; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,916 / 2,136] 20 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/objectivec/message.cc [for tool]; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/full/message_builder.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/generator.cc [for tool]; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,918 / 2,136] 18 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/full/message.cc [for tool]; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/message.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/generator.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/make_field_gens.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/enum.cc [for tool]; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,921 / 2,136] 15 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/make_field_gens.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/enum.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/extension.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/generator_factory.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,922 / 2,136] 14 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/enum_field.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/enum.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/extension.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/generator_factory.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,923 / 2,136] 13 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/enum.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/extension.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/generator_factory.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/kotlin/generator.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,924 / 2,136] 12 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/java/file.cc [for tool]; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/extension.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/generator_factory.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/generator.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_field.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,927 / 2,136] 9 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/file.cc [for tool]; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,928 / 2,136] 8 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/generator.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/kotlin/file.cc [for tool]; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,929 / 2,136] 7 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/map_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/kotlin/file.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 







[1,930 / 2,136] 6 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/message_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/kotlin/file.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 






[1,931 / 2,136] 5 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/compiler/kotlin/file.cc [for tool]; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 





[1,932 / 2,136] 4 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/java/lite/message.cc [for tool]; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../compiler/java/lite/primitive_field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 




[1,934 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/cpp/message.cc [for tool]; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/compiler/kotlin/field.cc [for tool]; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


[1,935 / 2,136] Compiling .../compiler/cpp/message.cc [for tool]; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: From Compiling src/google/protobuf/compiler/cpp/message.cc [for tool]:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:12:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/message.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/extension.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h:346:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   346 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:194:25: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   194 |   if (!field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:780:62: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":   780 |     if (!field->real_containing_oneof() && !field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:1152:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1152 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:1375:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1375 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:1408:55: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1408 |   if (!HasHasbit(field, options_) || field->options().weak()) return;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:2175:60: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2175 |             if (!field->is_repeated() && !field->options().weak() &&
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:2702:26: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  2702 |     if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:4329:35: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  4329 |       } else if (field->options().weak() ||
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:4677:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  4677 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:4984:39: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  4984 |                  if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:5528:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  5528 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:1375:24: warning: 'weak' is deprecated [-Wdeprecated-declarations]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1375 |   if (field->options().weak()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc:1430:11: note: in instantiation of function template specialization 'google::protobuf::compiler::cpp::MessageGenerator::EmitCheckAndUpdateByteSizeForField<false>' requested here
Step #3 - "compile-libfuzzer-coverage-x86_64":  1430 |           EmitCheckAndUpdateByteSizeForField</*kIsV2=*/false>(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h:7966:19: note: 'weak' has been explicitly marked deprecated here
Step #3 - "compile-libfuzzer-coverage-x86_64":  7966 |   [[nodiscard]] [[deprecated]] bool weak() const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 13 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,935 / 2,136] Compiling .../compiler/cpp/message.cc [for tool]; 25s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 
[1,961 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,964 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 0s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,964 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 1s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 1s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,964 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,965 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,965 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 2s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 2s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,966 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/internal/reference_count.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/internal/reference_count.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,966 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 3s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 3s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,967 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,968 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,969 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:empty_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/any.cc; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 4s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling extensions/protobuf/internal/map_reflection.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/map_reflection.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,971 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:timestamp_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:source_context_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:any_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/time.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,976 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:field_mask_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/time.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/time_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/proto_time_encoding.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:wrappers_proto; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/internal/byte_string.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/internal/byte_string.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/internal/byte_string.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/internal/byte_string.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/internal/byte_string.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 79 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,978 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/time.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/time_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:wrappers_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,982 / 2,136] 31 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:wrappers_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/json/internal/untyped_message.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,982 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:wrappers_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../protobuf/json/internal/untyped_message.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,983 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,984 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:value_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,985 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:api_proto; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,986 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:struct_proto; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,987 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_protobuf//src/google/protobuf:type_proto; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,988 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/memory.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/memory.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/memory.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/memory.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,988 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/basic_struct_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/basic_struct_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/basic_struct_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/basic_struct_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,989 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,989 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/type_resolver_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,991 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/util/field_mask_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_registry.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,992 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro_registry.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling extensions/protobuf/memory_manager.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/memory_manager.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/memory_manager.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/memory_manager.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/memory_manager.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/memory_manager.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/memory_manager.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/memory_manager.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 80 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,993 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,994 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:checked_proto; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 4s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,995 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,995 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     @com_google_cel_spec//proto/cel/expr:syntax_proto; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,996 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/enum_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/enum_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/enum_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/enum_type.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,996 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 5s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 5s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/function_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,997 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[1,998 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/type_introspector.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type_introspector.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type_introspector.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type_introspector.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,998 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type_introspector.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling extensions/protobuf/internal/qualify.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/qualify.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/internal/qualify.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/qualify.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/internal/qualify.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/qualify.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/internal/qualify.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/qualify.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/protobuf/internal/qualify.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 85 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [1,999 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/protobuf/internal/qualify.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,000 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/untyped_message.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/constant_proto.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,002 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/operators.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/function_type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,003 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/function_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/function_type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/function_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/function_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/function_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/function_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,003 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/function_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/list_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,003 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/function_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,005 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_number.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_number.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_number.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_number.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_number.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_number.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_number.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,005 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,006 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling fuzz/fuzz_parse.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_parse.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./parser/parser.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 2 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,006 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_value.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_value.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_value.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 82 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,007 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,008 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/internal/cel_value_equal.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/cel_value_equal.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/cel_value_equal.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/cel_value_equal.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/cel_value_equal.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/cel_value_equal.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/cel_value_equal.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/cel_value_equal.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 80 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,009 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/unparser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling src/google/protobuf/json/internal/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast/expr_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,013 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/list_type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/list_type_pool.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/list_type_pool.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/list_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/list_type_pool.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,013 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/macro.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,015 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_attribute.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/map_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,015 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_attribute.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling internal/json.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/json.cc:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/json.cc:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/json.cc:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/json.cc:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 79 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,016 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_attribute.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/containers/internal_field_backed_list_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_list_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_list_impl.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_list_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_list_impl.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_list_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_list_impl.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,016 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/json.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_attribute.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_attribute.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_attribute.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_attribute.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_attribute.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,018 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_attribute.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../containers/internal_field_backed_map_impl.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,019 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../containers/internal_field_backed_map_impl.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/message_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/message_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/message_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/message_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,019 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../containers/internal_field_backed_map_impl.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/containers/internal_field_backed_map_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_map_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_map_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_map_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_map_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_map_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/containers/internal_field_backed_map_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/containers/internal_field_backed_map_impl.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 79 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,020 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../containers/internal_field_backed_map_impl.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/cel_proto_wrapper.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrapper.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrapper.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrapper.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrapper.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrapper.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrapper.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrapper.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/proto_message_type_adapter.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrapper.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 88 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,021 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrapper.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/field_access_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/field_access_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/field_access_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/field_access_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/field_access_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/field_access_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/field_access_impl.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,022 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/map_type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,022 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/field_access_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/map_type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling internal/message_equality.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/message_equality.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/message_equality.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/message_equality.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/message_equality.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 79 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,023 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/message_equality.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/map_type_pool.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,024 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/map_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/map_type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/map_type_pool.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/map_type_pool.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/map_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/map_type_pool.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,024 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/map_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,025 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/proto_message_type_adapter.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/proto_message_type_adapter.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/proto_message_type_adapter.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/proto_message_type_adapter.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/proto_message_type_adapter.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:43:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/proto_message_type_adapter.cc:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 96 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,025 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/opaque_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,025 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/proto_message_type_adapter.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling internal/well_known_types.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/well_known_types.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/well_known_types.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/well_known_types.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./internal/well_known_types.h:53:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from internal/well_known_types.cc:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 79 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,027 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling internal/well_known_types.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/cel_proto_wrap_util.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrap_util.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrap_util.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrap_util.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrap_util.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/cel_proto_wrap_util.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/cel_proto_wrap_util.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 78 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,028 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/cel_proto_wrap_util.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,029 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/opaque_type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/optional_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/optional_type.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/optional_type.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/optional_type.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,029 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/opaque_type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,030 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/opaque_type_pool.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/opaque_type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/opaque_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/opaque_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/opaque_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/opaque_type_pool.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,030 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/opaque_type_pool.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/type_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,031 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,031 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/struct_type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/struct_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/struct_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/struct_type.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,032 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/type.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/type.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,033 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/type.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/ast_proto.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/ast_proto.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,034 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/ast_proto.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/type_pool.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,035 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/type_pool.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,036 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/internal/runtime_type_provider.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_type_provider.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,036 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_type_provider.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/legacy_type_provider.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/legacy_type_provider.cc:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:33:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 | MemoryManager ProtoMemoryManager(google::protobuf::Arena* arena);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/memory_manager.h:48:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    48 | ABSL_MUST_USE_RESULT T* NewInProtoArena(MemoryManager memory_manager,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 115 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,037 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/structs/legacy_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/type_type_pool.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/types/type_type_pool.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/types/type_type_pool.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/types/type_type_pool.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 9 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,038 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/types/type_type_pool.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,039 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/activation.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/activation.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/activation.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 104 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,039 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/activation.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,040 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_function.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function.cc:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/interop.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 111 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,040 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/evaluator_stack.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_stack.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_stack.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,041 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,041 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_stack.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,042 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     //runtime/internal:activation_attribute_matcher_access; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_function_registry.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_function_registry.cc:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/interop.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 111 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,042 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     //runtime/internal:activation_attribute_matcher_access; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,043 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../internal/activation_attribute_matcher_access.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/arithmetic_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/arithmetic_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/arithmetic_functions.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,043 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/arithmetic_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../internal/activation_attribute_matcher_access.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/function_registry.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/function_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,044 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 19s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/function_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../internal/activation_attribute_matcher_access.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/internal/activation_attribute_matcher_access.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/activation_attribute_matcher_access.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 109 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,045 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../internal/activation_attribute_matcher_access.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,046 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/bool_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/bool_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bool_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,046 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/bool_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/structs/protobuf_descriptor_type_provider.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_adapter.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_adapter.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_adapter.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/structs/protobuf_descriptor_type_provider.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 112 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,047 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling .../structs/protobuf_descriptor_type_provider.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,048 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 20s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/bytes_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/bytes_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/bytes_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,048 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/bytes_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,049 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 21s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/activation.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/activation.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/activation.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 105 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,049 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/activation.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,050 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/internal/convert_constant.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/convert_constant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/convert_constant.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,050 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/attribute_utility.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/attribute_utility.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/attribute_utility.h:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,050 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/attribute_utility.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/convert_constant.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,052 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 22s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/evaluator_core.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/evaluator_core.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,052 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/evaluator_core.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,053 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_list_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/custom_list_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_list_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,053 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_list_value.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/jump_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/jump_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/jump_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,054 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/jump_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/direct_expression_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/direct_expression_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,055 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,055 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 17s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/direct_expression_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling parser/parser.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from parser/parser.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./parser/parser.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser.cc:90:22: warning: unused variable 'kHiddenAccumulatorVariableName' [-Wunused-const-variable]
Step #3 - "compile-libfuzzer-coverage-x86_64":    90 | constexpr const char kHiddenAccumulatorVariableName[] = "@result";
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Step #3 - "compile-libfuzzer-coverage-x86_64": 3 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,056 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 23s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/internal/adapter_activation_impl.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,056 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling parser/parser.cc; 24s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/value.cc; 18s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/internal/adapter_activation_impl.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,058 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/internal/adapter_activation_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/internal/adapter_activation_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/adapter_activation_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/interop.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/internal/adapter_activation_impl.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 114 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,058 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/internal/adapter_activation_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/type_registry.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 112 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,059 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/type_registry.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/regex_match_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/regex_match_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/regex_match_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,060 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/regex_match_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/compiler_constant_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/compiler_constant_step.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/compiler_constant_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,061 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/compiler_constant_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/cel_type_registry.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_type_registry.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 113 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,062 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_type_registry.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,063 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/custom_map_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_map_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,064 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_map_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,066 / 2,136] 32 actions, 31 running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/custom_struct_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/custom_struct_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,066 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/custom_struct_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/double_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/double_value.cc:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,067 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/double_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/resolver.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 112 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,068 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,069 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/duration_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/duration_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,069 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/internal/runtime_env.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_env.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 113 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,069 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_env.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/duration_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,071 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/ternary_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ternary_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ternary_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,071 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ternary_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/error_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/error_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,072 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/error_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,073 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/type_conversion_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/type_conversion_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/type_conversion_functions.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,073 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/type_conversion_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/int_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/int_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,074 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,074 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/int_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/legacy_list_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_list_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,075 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_list_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/time_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/time_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/time_functions.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,076 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/time_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,077 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/legacy_map_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_map_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,077 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,078 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/legacy_struct_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/legacy_struct_value.cc:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,078 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/legacy_struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,079 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/string_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/string_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/string_functions.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,079 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/string_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,080 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/regex_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/regex_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/regex_functions.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,080 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/list_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/list_value.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,080 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/regex_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/list_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,082 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/map_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/map_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,082 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/map_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,083 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/comparison_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/comparison_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/comparison_functions.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,083 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/comparison_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,084 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/logical_functions.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/message_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:43:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/message_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,084 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/message_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/logical_functions.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,085 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/logical_functions.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/logical_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/logical_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/logical_functions.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,085 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/logical_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/null_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/null_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,086 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/opaque_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/opaque_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,087 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,088 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/optional_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/optional_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,088 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,089 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/flat_expr_builder_extensions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder_extensions.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 130 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,089 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder_extensions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,090 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_json_list_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_list_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_list_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,090 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/regex_precompilation_optimization.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/regex_precompilation_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/regex_precompilation_optimization.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 130 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,091 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/regex_precompilation_optimization.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,092 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_json_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_value.cc:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,092 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/shadowable_value_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/shadowable_value_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/shadowable_value_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,092 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/shadowable_value_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_json_map_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_json_map_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_json_map_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,094 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,095 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/comprehension_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/comprehension_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/comprehension_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,095 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/legacy_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/legacy_value.cc:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 121 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,095 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/comprehension_step.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/legacy_value.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 11s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/select_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/select_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/select_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,097 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/select_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 10s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/cel_expression_flat_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/cel_expression_flat_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/cel_expression_flat_impl.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/internal/interop.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 145 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,098 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/cel_expression_flat_impl.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,099 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_map_field_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/equality_steps.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/equality_steps.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/equality_steps.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,099 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/equality_steps.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_map_field_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_message_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_message_value.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_message_value.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:62:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:67:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    67 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:38: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/qualify.h:71:88: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 108 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,100 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_map_field_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_message_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_map_field_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_map_field_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_map_field_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_map_field_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_map_field_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,101 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_map_field_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_functions.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,102 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_repeated_field_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/optional_or_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/optional_or_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/optional_or_step.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,102 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_repeated_field_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/parsed_repeated_field_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_repeated_field_value.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_repeated_field_value.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/parsed_repeated_field_value.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/parsed_repeated_field_value.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,102 / 2,136] 32 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/optional_or_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/parsed_repeated_field_value.cc; 9s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/container_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_functions.cc:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,104 / 2,136] 30 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_functions.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/logic_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/logic_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/logic_step.h:8:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,105 / 2,136] 29 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/logic_step.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/qualified_reference_resolver.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/qualified_reference_resolver.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/qualified_reference_resolver.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 130 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,106 / 2,136] 28 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/qualified_reference_resolver.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,107 / 2,136] 27 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/constant_folding.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/constant_folding.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/constant_folding.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:136:68: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   136 |   void SetAttributeMatcher(const runtime_internal::AttributeMatcher* matcher) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/activation.h:175:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   175 |   const runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 132 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,107 / 2,136] 27 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/constant_folding.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/equality_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/equality_functions.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/equality_functions.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,108 / 2,136] 26 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/equality_functions.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/standard/container_membership_functions.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/standard/container_membership_functions.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/function.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/standard/container_membership_functions.cc:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/function_adapter.h:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/function_adapter.h:63:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |   static std::reference_wrapper<const Value> ToArg(AssignableType v) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,109 / 2,136] 25 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/standard/container_membership_functions.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,110 / 2,136] 24 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/public/builtin_func_registrar.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/builtin_func_registrar.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/builtin_func_registrar.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function_registry.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,110 / 2,136] 24 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/builtin_func_registrar.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/struct_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value.cc:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,111 / 2,136] 23 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/timestamp_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/timestamp_value.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,112 / 2,136] 22 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/timestamp_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/unknown_value.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/type_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/type_value.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,113 / 2,136] 21 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/type_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/unknown_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,114 / 2,136] 20 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/unknown_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/string_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/string_value.cc:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,114 / 2,136] 20 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/string_value.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/unknown_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/unknown_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/unknown_value.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,115 / 2,136] 19 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/unknown_value.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,116 / 2,136] 18 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/uint_value.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/uint_value.cc:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 102 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,116 / 2,136] 18 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/uint_value.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,117 / 2,136] 17 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/struct_value_builder.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/struct_value_builder.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/struct_value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./extensions/protobuf/internal/map_reflection.h:33:92: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    33 |                     const google::protobuf::MapKey& key, google::protobuf::MapValueConstRef* value)
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 103 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,117 / 2,136] 17 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/struct_value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,118 / 2,136] 16 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/value_variant.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bool_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bool_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bool_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_variant.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/value_variant.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.cc:494:17: warning: first argument in call to 'memcpy' is a pointer to non-trivially copyable type 'cel::common_internal::ValueVariant' [-Wnontrivial-memcall]
Step #3 - "compile-libfuzzer-coverage-x86_64":   494 |     std::memcpy(std::addressof(rhs), tmp, sizeof(ValueVariant));
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.cc:494:17: note: explicitly cast the pointer to silence this warning
Step #3 - "compile-libfuzzer-coverage-x86_64":   494 |     std::memcpy(std::addressof(rhs), tmp, sizeof(ValueVariant));
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 (void*)
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.cc:529:17: warning: first argument in call to 'memcpy' is a pointer to non-trivially copyable type 'cel::common_internal::ValueVariant' [-Wnontrivial-memcall]
Step #3 - "compile-libfuzzer-coverage-x86_64":   529 |     std::memcpy(std::addressof(lhs), tmp, sizeof(ValueVariant));
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.cc:529:17: note: explicitly cast the pointer to silence this warning
Step #3 - "compile-libfuzzer-coverage-x86_64":   529 |     std::memcpy(std::addressof(lhs), tmp, sizeof(ValueVariant));
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 (void*)
Step #3 - "compile-libfuzzer-coverage-x86_64": 94 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,118 / 2,136] 16 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_variant.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/compiler/comprehension_vulnerability_check.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/comprehension_vulnerability_check.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/comprehension_vulnerability_check.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 130 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,119 / 2,136] 15 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/comprehension_vulnerability_check.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 6s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,120 / 2,136] 14 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 6s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,120 / 2,136] 14 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/lazy_init_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/lazy_init_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/lazy_init_step.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,120 / 2,136] 14 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/lazy_init_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,121 / 2,136] 13 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 7s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 7s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/ident_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/ident_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/ident_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,121 / 2,136] 13 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/ident_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,122 / 2,136] 12 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling common/values/value_builder.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/legacy_value.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from common/values/value_builder.cc:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:34:49: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 | absl::Status ModernValue(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:68:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:83:46: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    83 |     const google::api::expr::runtime::CelList* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:88:45: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    88 |     const google::api::expr::runtime::CelMap* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:101:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   101 |     google::protobuf::Arena* arena, const google::api::expr::runtime::CelValue& value,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:104:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   104 |     google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena, const Value& value, bool unchecked = false);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/legacy_value.h:111:58: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   111 | TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 111 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,122 / 2,136] 12 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling common/values/value_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,123 / 2,136] 11 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/create_map_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_map_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_map_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,123 / 2,136] 11 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_map_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,124 / 2,136] 10 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/create_struct_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_struct_step.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_struct_step.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,124 / 2,136] 10 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_struct_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/function_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/function_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/function_step.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,125 / 2,136] 9 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/function_step.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 8s local ...
Step #3 - "compile-libfuzzer-coverage-x86_64": 








[2,126 / 2,136] 8 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling eval/eval/create_list_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/create_list_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/create_list_step.h:11:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,126 / 2,136] 8 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/create_list_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 8s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 








INFO: From Compiling runtime/internal/runtime_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:26:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_impl.h:28:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from runtime/internal/runtime_impl.cc:14:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 132 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,127 / 2,136] 7 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling runtime/internal/runtime_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 







INFO: From Compiling eval/eval/container_access_step.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/eval/container_access_step.cc:1:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/container_access_step.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 107 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,128 / 2,136] 6 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/eval/container_access_step.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 






[2,129 / 2,136] 5 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 





INFO: From Compiling fuzz/fuzz_eval.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./parser/parser.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:115:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |       const cel::Source& source, std::vector<ParseIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./parser/parser_interface.h:132:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   132 |     const cel::Source& source, std::vector<ParseIssue>* issues) const {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from fuzz/fuzz_eval.cc:23:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:47:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    47 |                                      google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/activation.h:163:48: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   163 |   const cel::runtime_internal::AttributeMatcher* attribute_matcher_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 118 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,129 / 2,136] 5 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling fuzz/fuzz_eval.cc; 9s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 





INFO: From Compiling eval/public/cel_expr_builder_factory.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/memory.h:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:9:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_attribute.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:41:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/base_activation.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_function.h:10:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/legacy_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_type_registry.h:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expr_builder_factory.h:7:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/public/cel_expr_builder_factory.cc:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 145 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,130 / 2,136] 4 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/public/cel_expr_builder_factory.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 




[2,131 / 2,136] 3 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 



INFO: From Compiling eval/compiler/cel_expression_builder_flat_impl.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:33:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/cel_expression_builder_flat_impl.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/cel_expression.h:13:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/base_activation.h:41:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    41 |                                              google::protobuf::Arena*) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:59:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:60:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    60 |       const cel::expr::SourceInfo* source_info) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:63:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    63 |       const cel::expr::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:64:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    64 |       const cel::expr::SourceInfo* source_info,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:65:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    65 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:68:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    68 |       const cel::expr::CheckedExpr* checked_expr) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:71:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       const cel::expr::CheckedExpr* checked_expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:72:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<absl::Status>* warnings) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:82:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    82 |   CelFunctionRegistry* GetRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:89:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    89 |   CelTypeRegistry* GetTypeRegistry() const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/cel_expression_builder_flat_impl.h:100:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   100 |       std::vector<absl::Status>* warnings) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:31:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:40:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    40 |       google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:45:26: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    45 |   google::protobuf::Arena* arena() { return state_.arena(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:71:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    71 |       google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:74:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    74 |                                     google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:79:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    79 |                                     CelEvaluationState* state) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:81:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    81 |       const BaseActivation& activation, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:87:52: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    87 |                                  CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:108:53: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   108 |     explicit EvaluationState(google::protobuf::Arena* arena) : arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:109:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |     google::protobuf::Arena* arena() { return arena_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:112:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   112 |     google::protobuf::Arena* arena_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:129:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   129 |       google::protobuf::Arena* arena) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:134:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   134 |                                     google::protobuf::Arena* arena) const override;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:137:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   137 |                                     CelEvaluationState* state) const override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:143:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   143 |                                  google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:147:59: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   147 |       const BaseActivation& activation, CelEvaluationState* state,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:156:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   156 |   const DirectExpressionStep* root() const { return root_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/cel_expression_flat_impl.h:170:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   170 |   const DirectExpressionStep* root_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/cel_expression_builder_flat_impl.cc:35:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/protobuf/ast_converters.h:25:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/ast_proto.h:34:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    34 |     const cel::expr::SourceInfo* source_info = nullptr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 161 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,131 / 2,136] 3 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/cel_expression_builder_flat_impl.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 10s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 



[2,132 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 11s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


[2,132 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 12s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


[2,132 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 13s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


[2,132 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


INFO: From Compiling extensions/select_optimization.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:20:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:15:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./extensions/select_optimization.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:94:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    94 |   TypeRegistry* type_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime_builder.h:95:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    95 |   FunctionRegistry* function_registry_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:49:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from extensions/select_optimization.cc:60:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/runtime_impl.h:121:44: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 | bool TestOnly_IsRecursiveImpl(const Program* program);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 134 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,132 / 2,136] 2 actions running
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling eval/compiler/flat_expr_builder.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64":     Compiling extensions/select_optimization.cc; 14s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 


[2,133 / 2,136] Compiling eval/compiler/flat_expr_builder.cc; 15s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: From Compiling eval/compiler/flat_expr_builder.cc:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:48:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/enum_type.h:121:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   121 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type.h:55:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:128:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   128 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/types/message_type.h:193:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   193 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:21:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_introspector.h:24:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:962:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   962 |   const_pointer data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:967:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   967 |   const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:969:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   969 |   const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:973:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   973 |   const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:977:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   977 |   const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/type.h:1007:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1007 |     const Type* external_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/optional_ref.h:109:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   109 |   T* const value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:34:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:91:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    91 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:258:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   258 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:269:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   269 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:276:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   276 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:281:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   281 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:290:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   290 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:322:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   322 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:366:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   366 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:381:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   381 |   void deallocate(pointer, size_type) noexcept {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^      
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull 
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:384:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   384 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:390:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   390 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:459:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   459 |   ABSL_MUST_USE_RESULT void* allocate_bytes(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:468:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   468 |       void* p, size_type nbytes,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:476:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   476 |   ABSL_MUST_USE_RESULT T* allocate_object(size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:483:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   void deallocate_object(T* p, size_type n = 1) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:493:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   493 |   ABSL_MUST_USE_RESULT T* new_object(Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:503:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   503 |   void delete_object(T* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:540:3: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   540 |   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:553:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   553 |   void deallocate(pointer p, size_type n) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:559:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   559 |   void construct(U* p, Args&&... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/allocator.h:566:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   566 |   void destroy(U* p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:37:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/reference_count.h:179:36: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   179 |   explicit EmplacedReferenceCount(T*& value, Args&&... args) noexcept(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/internal/byte_string.h:38:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:93:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    93 | Owned<const T> WrapEternal(const T* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:107:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   107 | Owned<T> WrapShared(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:225:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   225 |   friend Owned<T> WrapShared(T* object, cel::Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:452:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   452 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:455:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   455 | Unique<T> WrapUnique(T* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:485:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   485 |   explicit Unique(T* ptr) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:519:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   519 |   Unique& operator=(U* other) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:556:25: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   556 |   ABSL_MUST_USE_RESULT T* release() noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:563:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   563 |   void reset(T* ptr) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:596:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   596 |   friend Unique<U> WrapUnique(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:602:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   602 |   Unique(T* ptr, uintptr_t arena) noexcept : ptr_(ptr), arena_(arena) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:604:41: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   604 |   Unique(T* ptr, google::protobuf::Arena* arena, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:33: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:611:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   611 |   Unique(google::protobuf::Arena* arena, T* ptr, bool unowned = false) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:614:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   614 |   T* get() const noexcept { return ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:646:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   646 |   void Release(T** ptr, Owner* owner) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:663:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   663 |   T* ptr_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:670:9: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   670 | Unique(T*) -> Unique<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:708:62: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   708 | std::enable_if_t<!std::is_const_v<T>, Unique<T>> WrapUnique(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:713:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   713 | Unique<T> WrapUnique(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:750:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   750 |   static element_type* to_address(const pointer& p) noexcept { return p.ptr_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:809:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   809 |   Owned(Owner owner, T* value ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:900:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   900 |   friend Owned<U> WrapShared(U* object, Allocator<> allocator);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:902:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   902 |   friend Owned<const U> common_internal::WrapEternal(const U* value);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:906:10: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   906 |   Owned(T* value, Owner owner) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:909:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   909 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:911:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   911 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:916:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   916 | Owned(T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:920:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   920 | Owned(Owner, T*) -> Owned<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:937:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   937 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1019:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1019 | Owned<T> WrapShared(T* object, Allocator<> allocator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1035:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1035 | std::enable_if_t<!std::is_const_v<T>, Owned<T>> WrapShared(T* object) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1042:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1042 | Owned<const T> WrapEternal(const T* value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1088:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1088 |   Borrowed(Borrower borrower, T* ptr) noexcept : Borrowed(ptr, borrower) {}
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1166:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1166 |   constexpr Borrowed(T* value, Borrower borrower) noexcept
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1169:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1169 |   T* get() const noexcept { return value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1171:4: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1171 |   T* value_ = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1176:11: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1176 | Borrowed(T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |            _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1178:21: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1178 | Borrowed(Borrower, T*) -> Borrowed<T>;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1195:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1195 |   static element_type* to_address(pointer p) noexcept { return p.value_; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1316:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1316 |   static void* Allocate(size_t size, size_t alignment);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1318:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1318 |   static bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1339:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1339 |   ABSL_MUST_USE_RESULT static void* Allocate(google::protobuf::Arena* absl_nonnull arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1354:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1354 |   static bool Deallocate(google::protobuf::Arena* absl_nonnull, void*, size_t,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1365:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1365 |                                   void* object,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1366:69: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1366 |                                   void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1373:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1373 |   static void DefaultDestructor(void* ptr) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1435:28: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1435 |   ABSL_MUST_USE_RESULT void* Allocate(size_t size, size_t alignment) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1448:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1448 |   bool Deallocate(void* ptr, size_t size, size_t alignment) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:32: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/memory.h:1461:76: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":  1461 |   bool OwnCustomDestructor(void* object, void (*absl_nonnull destruct)(void*)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/bytes_value.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/internal/byte_string.h:119:13: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const char* data;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:46:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:24: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:49:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |   bool Next(const void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_input_stream.h:77:27: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   bool ReadCord(absl::Cord* cord, int count) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:17: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:18: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:51:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    51 |   bool Next(void** data, int* size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/bytes_value_output_stream.h:80:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    80 |   bool WriteAliasedRaw(const void* data, int size) override {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:56:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/list_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_list_value.h:222:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   222 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:57:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value.h:52:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/map_value_variant.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_json_map_value.h:243:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   243 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/value.h:58:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/values/message_value.h:47:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/values/parsed_message_value.h:244:22: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   244 |   static element_type* to_address(const pointer& p) noexcept {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                        _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./base/type_provider.h:18:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./common/type_reflector.h:22:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:480:8: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   480 |   Value* operator->() { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./common/value.h:483:14: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   483 |   const Value* operator->() const { return this; }
Step #3 - "compile-libfuzzer-coverage-x86_64":       |              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:77:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    77 |   virtual const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/legacy_type_info_apis.h:86:39: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    86 |   virtual const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:44:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/resolver.h:36:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/type_registry.h:32:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/legacy_runtime_type_provider.h:19:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/public/structs/protobuf_descriptor_type_provider.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:42:61: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    42 |   ProtoMessageTypeAdapter(const google::protobuf::Descriptor* descriptor,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:59:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    59 |   const LegacyTypeAccessApis* GetAccessApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:62:31: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    62 |   const LegacyTypeMutationApis* GetMutationApis(
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:114:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   114 |   absl::Status SetField(const google::protobuf::FieldDescriptor* field,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:115:71: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   115 |                         const CelValue& value, google::protobuf::Arena* arena,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:116:50: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   116 |                         google::protobuf::Message* message) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:118:35: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   118 |   google::protobuf::MessageFactory* message_factory_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/structs/proto_message_type_adapter.h:119:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   119 |   const google::protobuf::Descriptor* descriptor_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:39:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:39:29: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    39 |       const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                               _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/internal/activation_attribute_matcher_access.h:49:57: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    49 |                                   const AttributeMatcher* matcher);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                           _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/evaluator_core.h:40:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./runtime/runtime.h:191:30: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   191 |     std::vector<RuntimeIssue>* issues = nullptr;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:45:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/eval/direct_expression_step.h:27:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:75:47: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    75 |   virtual absl::Status Evaluate(ExecutionFrame* context) const = 0;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/eval/evaluator_core.h:342:23: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   342 |   const ExpressionStep* Next();
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder_extensions.h:50:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./runtime/internal/runtime_env.h:29:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/public/cel_type_registry.h:70:55: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    70 |   void Register(const google::protobuf::EnumDescriptor* enum_descriptor);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                         _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from ./eval/compiler/flat_expr_builder.h:30:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:189:60: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   189 |     Subexpression* absl_nullable ExtractChild(Subexpression* child);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                              _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:34: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:208:56: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   208 |     Subexpression(const cel::Expr* self, ProgramBuilder* owner);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                          _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:218:20: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   218 |     const cel::Expr* self_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                      _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:220:19: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   220 |     ProgramBuilder* owner_;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                     _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:252:66: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   252 |   Subexpression* absl_nullable EnterSubexpression(const cel::Expr* expr,
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                    _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:260:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   260 |   Subexpression* absl_nullable ExitSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:266:64: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   266 |   Subexpression* absl_nullable GetSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                  _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:282:43: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   282 |   int ExtractSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                             _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:298:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   298 |   Subexpression* absl_nullable MakeSubexpression(const cel::Expr* expr);
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:65: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                                                   _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder_extensions.h:308:15: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":   308 | const Subclass* TryDowncastDirectStep(const DirectExpressionStep* step) {
Step #3 - "compile-libfuzzer-coverage-x86_64":       |               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                 _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": In file included from eval/compiler/flat_expr_builder.cc:17:
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: warning: pointer is missing a nullability type specifier (_Nonnull, _Nullable, or _Null_unspecified) [-Wnullability-completeness]
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nullable' if the pointer may be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nullable
Step #3 - "compile-libfuzzer-coverage-x86_64": ./eval/compiler/flat_expr_builder.h:72:37: note: insert '_Nonnull' if the pointer should never be null
Step #3 - "compile-libfuzzer-coverage-x86_64":    72 |       std::vector<cel::RuntimeIssue>* issues) const;
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":       |                                       _Nonnull
Step #3 - "compile-libfuzzer-coverage-x86_64": 131 warnings generated.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,133 / 2,136] Compiling eval/compiler/flat_expr_builder.cc; 16s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 
[2,134 / 2,136] Linking fuzz/fuzz_eval_raw_; 0s local
Step #3 - "compile-libfuzzer-coverage-x86_64": 
[2,135 / 2,136] [Prepa] Action fuzz/fuzz_eval_oss_fuzz.tar
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: Found 2 targets...
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,136 / 2,136] no actions running
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: Elapsed time: 186.685s, Critical Path: 70.88s
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,136 / 2,136] no actions running
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: 2136 processes: 1105 internal, 1031 local.
Step #3 - "compile-libfuzzer-coverage-x86_64": [2,136 / 2,136] no actions running
Step #3 - "compile-libfuzzer-coverage-x86_64": 
INFO: Build completed successfully, 2136 total actions
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ find bazel-bin/ -name '*oss_fuzz.tar'
Step #3 - "compile-libfuzzer-coverage-x86_64": + for oss_fuzz_archive in $(find bazel-bin/ -name "*oss_fuzz.tar")
Step #3 - "compile-libfuzzer-coverage-x86_64": + tar --no-same-owner -xvf bazel-bin/fuzz/fuzz_parse_oss_fuzz.tar -C /workspace/out/libfuzzer-coverage-x86_64
Step #3 - "compile-libfuzzer-coverage-x86_64": ./
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_parse
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_parse_seed_corpus.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_parse.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_parse.runfiles/_repo_mapping
Step #3 - "compile-libfuzzer-coverage-x86_64": + for oss_fuzz_archive in $(find bazel-bin/ -name "*oss_fuzz.tar")
Step #3 - "compile-libfuzzer-coverage-x86_64": + tar --no-same-owner -xvf bazel-bin/fuzz/fuzz_eval_oss_fuzz.tar -C /workspace/out/libfuzzer-coverage-x86_64
Step #3 - "compile-libfuzzer-coverage-x86_64": ./
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_eval
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_eval_seed_corpus.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_eval.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": ./fuzz_eval.runfiles/_repo_mapping
Step #3 - "compile-libfuzzer-coverage-x86_64": + '[' coverage = coverage ']'
Step #3 - "compile-libfuzzer-coverage-x86_64": + echo 'Collecting the repository source files for coverage tracking.'
Step #3 - "compile-libfuzzer-coverage-x86_64": Collecting the repository source files for coverage tracking.
Step #3 - "compile-libfuzzer-coverage-x86_64": + declare -r COVERAGE_SOURCES=/workspace/out/libfuzzer-coverage-x86_64/proc/self/cwd
Step #3 - "compile-libfuzzer-coverage-x86_64": + mkdir -p /workspace/out/libfuzzer-coverage-x86_64/proc/self/cwd
Step #3 - "compile-libfuzzer-coverage-x86_64": + RSYNC_FILTER_ARGS=("--include" "*.h" "--include" "*.cc" "--include" "*.hpp" "--include" "*.cpp" "--include" "*.c" "--include" "*.inc" "--include" "*/" "--exclude" "*")
Step #3 - "compile-libfuzzer-coverage-x86_64": + declare -r RSYNC_FILTER_ARGS
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ bazel info execution_root
Step #3 - "compile-libfuzzer-coverage-x86_64": WARNING: For repository 'rules_java', the root module requires module version rules_java@8.6.1, but got rules_java@8.14.0 in the resolved dependency graph. Please update the version in your MODULE.bazel or set --check_direct_dependencies=off
Step #3 - "compile-libfuzzer-coverage-x86_64": + rsync -avLk --include '*.h' --include '*.cc' --include '*.hpp' --include '*.cpp' --include '*.c' --include '*.inc' --include '*/' --exclude '*' /root/.cache/bazel/_bazel_root/9237247786220dac906b18800270f37f/execroot/_main/ /workspace/out/libfuzzer-coverage-x86_64/proc/self/cwd/
Step #3 - "compile-libfuzzer-coverage-x86_64": sending incremental file list
Step #3 - "compile-libfuzzer-coverage-x86_64": ./
Step #3 - "compile-libfuzzer-coverage-x86_64": .bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/branches/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/hooks/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/info/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/logs/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/logs/refs/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/logs/refs/heads/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/logs/refs/remotes/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/logs/refs/remotes/origin/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/objects/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/objects/info/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/objects/pack/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/refs/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/refs/heads/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/refs/remotes/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/refs/remotes/origin/
Step #3 - "compile-libfuzzer-coverage-x86_64": .git/refs/tags/
Step #3 - "compile-libfuzzer-coverage-x86_64": .github/
Step #3 - "compile-libfuzzer-coverage-x86_64": .github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": base/
Step #3 - "compile-libfuzzer-coverage-x86_64": base/ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/attribute.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/attribute.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/attribute_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/builtins.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function_descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function_result.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function_result_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/function_result_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/kind.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/operators.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/operators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/operators_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/type_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/memory_manager_testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/memory_manager_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/message_wrapper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/operators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/unknown_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": base/internal/unknown_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/_tmp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/_tmp/actions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/_objs/attributes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/_objs/function_result_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/base/internal/_objs/unknown_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/any/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/ast/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/ast_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/ast_rewrite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/ast_traverse/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/constant/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/function_descriptor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/kind/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/memory/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/operators/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/source/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/type/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/typeinfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/_objs/value/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/_objs/constant_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/_objs/expr_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/_objs/metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/ast/_objs/source_info_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/internal/_objs/byte_string/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/common/internal/_objs/reference_count/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/cel_expression_builder_flat_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/check_ast_extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/comprehension_vulnerability_check/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/constant_folding/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/flat_expr_builder/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/flat_expr_builder_extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/qualified_reference_resolver/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/regex_precompilation_optimization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/compiler/_objs/resolver/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/attribute_trail/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/attribute_utility/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/cel_expression_flat_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/compiler_constant_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/comprehension_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/container_access_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/create_list_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/create_map_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/create_struct_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/direct_expression_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/equality_steps/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/evaluator_core/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/evaluator_stack/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/function_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/ident_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/jump_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/lazy_init_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/logic_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/optional_or_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/regex_match_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/select_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/shadowable_value_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/eval/_objs/ternary_step/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/internal/_objs/adapter_activation_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/internal/_objs/cel_value_equal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/internal/_objs/errors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/activation/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/builtin_func_registrar/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_attribute/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_expr_builder_factory/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_function/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_function_registry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_number/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_options/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_type_registry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/cel_value/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/_objs/unknown_function_result_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/containers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/containers/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/containers/_objs/internal_field_backed_list_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/containers/_objs/internal_field_backed_map_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/cel_proto_wrap_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/cel_proto_wrapper/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/field_access_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/legacy_type_provider/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/proto_message_type_adapter/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/eval/public/structs/_objs/protobuf_descriptor_type_provider/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/_objs/select_optimization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/_objs/memory_manager/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/internal/_objs/map_reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/extensions/protobuf/internal/_objs/qualify/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/algorithm/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/log_severity/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/malloc_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/raw_logging_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/spinlock_wait/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/strerror/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/throw_delegate/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/base/_objs/tracing_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/cleanup/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/container/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/container/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/container/_objs/hashtablez_sampler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/container/_objs/raw_hash_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/_objs/cpu_detect/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/_objs/crc32c/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/_objs/crc_cord_state/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/crc/_objs/crc_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/borrowed_fixup_buffer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/debugging_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/decode_rust_punycode/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/demangle_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/demangle_rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/examine_stack/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/leak_check/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/stacktrace/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/symbolize/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/debugging/_objs/utf8_for_code_point/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/commandlineflag/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/commandlineflag_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/config/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/flag_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/marshalling/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/private_handle_accessor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/program_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/flags/_objs/reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/functional/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/hash/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/hash/_objs/city/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/hash/_objs/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/_objs/die_if_null/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/_objs/globals/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/_objs/log_entry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/_objs/log_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/check_op/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/conditions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/fnmatch/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/format/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/globals/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/log_message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/log_sink_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/nullguard/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/structured_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/log/internal/_objs/vlog_config/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/memory/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/meta/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/numeric/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/numeric/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/numeric/_objs/int128/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/profiling/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/profiling/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/profiling/_objs/exponential_biased/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/status/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/status/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/status/_objs/status/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/status/_objs/statusor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/cord/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/cord_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/cordz_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/cordz_handle/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/cordz_info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/str_format_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/strings/_objs/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/synchronization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/synchronization/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/synchronization/_objs/graphcycles_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/synchronization/_objs/kernel_timeout_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/synchronization/_objs/synchronization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/_objs/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/internal/cctz/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/civil_time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/time_zone/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/types/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/abseil-cpp+/absl/utility/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/antlr4-cpp-runtime+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/antlr4-cpp-runtime+/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/antlr4-cpp-runtime+/_objs/antlr4-cpp-runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/bazel_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/bazel_tools/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/bazel_tools/tools/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_objs/checked_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_objs/syntax_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_objs/value_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/checked_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/checked_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/checked_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/checked_proto/cel/expr/checked.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/checked_proto/cel/expr/checked.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/syntax_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/syntax_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/syntax_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/syntax_proto/cel/expr/syntax.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/syntax_proto/cel/expr/syntax.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/value_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/value_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/value_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/value_proto/cel/expr/value.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_imports/value_proto/cel/expr/value.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/checked_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/checked_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/checked_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/checked_proto/cel/expr/checked.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/syntax_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/syntax_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/syntax_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/syntax_proto/cel/expr/syntax.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/value_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/value_proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/value_proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/cel-spec+/proto/cel/expr/_virtual_includes/value_proto/cel/expr/value.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/any_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/api_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/arena/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/arena_align/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/duration_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/empty_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/field_mask_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/micro_string/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/protobuf_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/source_context_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/struct_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/timestamp_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/type_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_objs/wrappers_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/any_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/any_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/any_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/any_proto/google/protobuf/any.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/any_proto/google/protobuf/any.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/api_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/api_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/api_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/api_proto/google/protobuf/api.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/api_proto/google/protobuf/api.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/duration_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/duration_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/duration_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/duration_proto/google/protobuf/duration.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/duration_proto/google/protobuf/duration.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/empty_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/empty_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/empty_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/empty_proto/google/protobuf/empty.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/empty_proto/google/protobuf/empty.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/field_mask_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/field_mask_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/field_mask_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/field_mask_proto/google/protobuf/field_mask.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/field_mask_proto/google/protobuf/field_mask.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/source_context_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/source_context_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/source_context_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/source_context_proto/google/protobuf/source_context.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/source_context_proto/google/protobuf/source_context.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/struct_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/struct_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/struct_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/struct_proto/google/protobuf/struct.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/struct_proto/google/protobuf/struct.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/timestamp_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/timestamp_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/timestamp_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/timestamp_proto/google/protobuf/timestamp.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/timestamp_proto/google/protobuf/timestamp.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/type_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/type_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/type_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/type_proto/google/protobuf/type.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/type_proto/google/protobuf/type.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/wrappers_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/wrappers_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/wrappers_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/wrappers_proto/google/protobuf/wrappers.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_imports/wrappers_proto/google/protobuf/wrappers.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/any_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/any_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/any_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/any_proto/google/protobuf/any.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/api_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/api_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/api_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/api_proto/google/protobuf/api.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/arenaz_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/serial_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/thread_safe_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/protobuf/arena_align.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/protobuf/arena_allocation_policy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/protobuf/arena_cleanup.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/descriptor_legacy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/descriptor_legacy/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/descriptor_legacy/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/descriptor_legacy/google/protobuf/descriptor_legacy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/duration_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/duration_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/duration_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/duration_proto/google/protobuf/duration.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/empty_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/empty_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/empty_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/empty_proto/google/protobuf/empty.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/protobuf/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/field_mask_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/field_mask_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/field_mask_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/field_mask_proto/google/protobuf/field_mask.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/protobuf/internal_visibility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/protobuf/micro_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/os_macros_restore.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/os_macros_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port_def.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/cpp_edition_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/cpp_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/dynamic_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/feature_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/field_access_listener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_enum_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_bases.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_tctable_gen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/internal_feature_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/map_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_mode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_ops.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_field_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/text_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/unknown_field_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/wire_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/cpp_edition_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/cpp_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/descriptor.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/descriptor_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/dynamic_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/feature_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/field_access_listener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/generated_enum_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/generated_message_bases.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/generated_message_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/generated_message_tctable_gen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/internal_feature_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/map_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection_mode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection_ops.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection_visit_field_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/reflection_visit_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/text_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/unknown_field_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_layering_check_legacy/google/protobuf/wire_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arenastring.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arenaz_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/descriptor_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/explicitly_constructed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/extension_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/extension_set_inl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/field_with_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_enum_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_tctable_decl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_tctable_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/has_bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/implicit_weak_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/inlined_string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/internal_metadata_locator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/internal_visibility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map_field_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map_type_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/message_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/metadata_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/parse_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/raw_ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/repeated_ptr_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/runtime_version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/serial_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/thread_safe_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/wire_format_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/source_context_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/source_context_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/source_context_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/source_context_proto/google/protobuf/source_context.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/protobuf/string_block.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/struct_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/struct_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/struct_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/struct_proto/google/protobuf/struct.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/protobuf/symbol_checker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/timestamp_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/timestamp_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/timestamp_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/timestamp_proto/google/protobuf/timestamp.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/type_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/type_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/type_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/type_proto/google/protobuf/type.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/protobuf/varint_shuffle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/wrappers_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/wrappers_proto/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/wrappers_proto/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/_virtual_includes/wrappers_proto/google/protobuf/wrappers.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_objs/importer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/importer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/gzip_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/io_win32/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/printer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/tokenizer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_objs/zero_copy_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/io/gzip_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/coded_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream_impl_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/io/io_win32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/io/printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/strtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/tokenizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/io/zero_copy_sink.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/lexer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/message_path/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/unparser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/untyped_message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/writer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_objs/zero_copy_buffered_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/descriptor_traits/google/protobuf/json/internal/descriptor_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/json/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/json/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/json/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/json/google/protobuf/json/json.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/lexer/google/protobuf/json/internal/lexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/message_path/google/protobuf/json/internal/message_path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/protobuf/json/internal/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/parser/google/protobuf/json/internal/parser_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/protobuf/json/internal/unparser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/unparser/google/protobuf/json/internal/unparser_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/untyped_message/google/protobuf/json/internal/untyped_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/writer/google/protobuf/json/internal/writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/json/_virtual_includes/zero_copy_buffered_stream/google/protobuf/json/internal/zero_copy_buffered_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_objs/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/callback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/platform_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/status_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/delimited_message_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/differencer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/field_mask_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/time_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_objs/type_resolver/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/delimited_message_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/delimited_message_util/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/delimited_message_util/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/delimited_message_util/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/delimited_message_util/google/protobuf/util/delimited_message_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/google/protobuf/util/field_comparator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/differencer/google/protobuf/util/message_differencer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/field_mask_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/field_mask_util/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/field_mask_util/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/field_mask_util/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/field_mask_util/google/protobuf/util/field_mask_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/internal_timeval/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/internal_timeval/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/internal_timeval/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/internal_timeval/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/internal_timeval/google/protobuf/util/internal_timeval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/json_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/json_util/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/json_util/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/json_util/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/json_util/google/protobuf/util/json_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/time_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/time_util/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/time_util/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/time_util/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/time_util/google/protobuf/util/time_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/google/protobuf/util/type_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/src/google/protobuf/util/_virtual_includes/type_resolver/google/protobuf/util/type_resolver_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_objs/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range_neon.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range_sse.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_validity/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_validity/utf8_validity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/re2+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/re2+/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/re2+/_objs/re2/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/rules_cc+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/rules_fuzzing++non_module_dependencies+rules_fuzzing_oss_fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/_objs/z/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/crc32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/deflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/gzguts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/inffast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/inffixed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/inflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/inftrees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/trees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/zconf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/zlib.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/external/zlib+/zlib/include/zutil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/fuzz/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/fuzz/_objs/fuzz_eval_raw_/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/fuzz/_objs/fuzz_parse_raw_/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/empty_descriptor_set_embed.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/empty_descriptors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/lexis/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/message_equality/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/new/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/overflow/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/proto_time_encoding/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/string_pool/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/utf8/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/internal/_objs/well_known_types/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/_objs/macro/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/_objs/macro_expr_factory/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/_objs/macro_registry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/_objs/parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelBaseVisitor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelBaseVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelLexer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelLexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelParser.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelParser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelVisitor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/CelVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/_objs/cel_cc_parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelBaseVisitor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelBaseVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelLexer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelLexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelParser.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelParser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelVisitor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/parser/internal/cel_grammar/parser/internal/CelVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/_objs/activation/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/_objs/function_registry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/_objs/type_registry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/activation_attribute_matcher_access/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/convert_constant/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/errors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/runtime_env/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/runtime_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/internal/_objs/runtime_type_provider/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/arithmetic_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/comparison_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/container_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/container_membership_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/equality_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/logical_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/regex_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/string_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/time_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-ST-19bbf383b921/bin/runtime/standard/_objs/type_conversion_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/antlr4_tool/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/antlr4_tool/antlr4_tool_classes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/antlr4_tool/antlr4_tool_sources/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/antlr4_tool/antlr4_tool_tmp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_javac/antlr4_tool/antlr4_tool_tmp/native_headers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_objs/cat_param_file/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/_objs/cel_cc_embed/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/+_repo_rules+antlr4_jar/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/+_repo_rules+antlr4_jar/jar/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/_main/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/management/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/security/policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/security/policy/limited/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/conf/security/policy/unlimited/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/classfile_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/jawt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/jdwpTransport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/jni.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/jvmti.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/jvmticmlr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/linux/jawt_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/include/linux/jni_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/lib/jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/lib/jli/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/lib/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/antlr4_tool.runfiles/rules_java++toolchains+remotejdk11_linux/lib/server/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cat_param_file.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cat_param_file.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cat_param_file.runfiles/_main/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cel_cc_embed.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cel_cc_embed.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/bazel/cel_cc_embed.runfiles/_main/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/algorithm/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/log_severity/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/malloc_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/raw_logging_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/spinlock_wait/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/strerror/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/throw_delegate/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/base/_objs/tracing_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/cleanup/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/container/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/container/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/container/_objs/hashtablez_sampler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/container/_objs/raw_hash_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/_objs/cpu_detect/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/_objs/crc32c/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/_objs/crc_cord_state/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/crc/_objs/crc_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/borrowed_fixup_buffer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/debugging_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/decode_rust_punycode/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/demangle_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/demangle_rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/examine_stack/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/leak_check/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/stacktrace/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/symbolize/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/debugging/_objs/utf8_for_code_point/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/commandlineflag/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/commandlineflag_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/config/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/flag_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/marshalling/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/parse/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/private_handle_accessor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/program_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/usage/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/flags/_objs/usage_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/functional/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/hash/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/hash/_objs/city/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/hash/_objs/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/die_if_null/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/globals/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/initialize/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/log_entry/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/_objs/log_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/check_op/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/conditions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/fnmatch/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/format/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/globals/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/log_message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/log_sink_set/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/nullguard/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/structured_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/log/internal/_objs/vlog_config/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/memory/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/meta/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/numeric/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/numeric/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/numeric/_objs/int128/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/profiling/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/profiling/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/profiling/_objs/exponential_biased/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/status/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/status/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/status/_objs/status/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/status/_objs/statusor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/cord/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/cord_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/cordz_functions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/cordz_handle/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/cordz_info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/str_format_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/strings/_objs/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/synchronization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/synchronization/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/synchronization/_objs/graphcycles_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/synchronization/_objs/kernel_timeout_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/synchronization/_objs/synchronization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/_objs/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/internal/cctz/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/civil_time/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/time/internal/cctz/_objs/time_zone/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/types/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/abseil-cpp+/absl/utility/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/bazel_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/bazel_tools/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/bazel_tools/tools/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/protoc.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/protoc.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/protoc.runfiles/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/arena/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/arena_align/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/micro_string/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_objs/protobuf_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/arenaz_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/serial_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena/google/protobuf/thread_safe_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_align/google/protobuf/arena_align.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_allocation_policy/google/protobuf/arena_allocation_policy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/arena_cleanup/google/protobuf/arena_cleanup.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/endian/google/protobuf/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/internal_visibility/google/protobuf/internal_visibility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/micro_string/google/protobuf/micro_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/os_macros_restore.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/os_macros/google/protobuf/os_macros_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port_def.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/port/google/protobuf/port_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/cpp_edition_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/cpp_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/descriptor_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/dynamic_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/feature_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/field_access_listener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_enum_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_bases.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/generated_message_tctable_gen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/internal_feature_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/map_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_mode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_ops.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_field_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/reflection_visit_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/text_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/unknown_field_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf/google/protobuf/wire_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arenastring.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/arenaz_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/descriptor_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/explicitly_constructed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/extension_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/extension_set_inl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/field_with_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_enum_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_tctable_decl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_tctable_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/generated_message_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/has_bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/implicit_weak_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/inlined_string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/internal_metadata_locator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/internal_visibility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map_field_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/map_type_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/message_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/metadata_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/parse_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/raw_ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/repeated_ptr_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/runtime_version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/serial_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/thread_safe_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/protobuf_lite/google/protobuf/wire_format_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/string_block/google/protobuf/string_block.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/symbol_checker/google/protobuf/symbol_checker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/_virtual_includes/varint_shuffle/google/protobuf/varint_shuffle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/code_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/code_generator_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/command_line_interface/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/importer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/protoc_lib_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/protoc_minimal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/retention/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_objs/versions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/compiler/code_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/compiler/plugin.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/compiler/plugin.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator/google/protobuf/compiler/scc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator_lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator_lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator_lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator_lite/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/code_generator_lite/google/protobuf/compiler/code_generator_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/compiler/command_line_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/compiler/notices.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/compiler/subprocess.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/command_line_interface/google/protobuf/compiler/zip_writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/importer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/importer/google/protobuf/compiler/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/plugin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/plugin/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/plugin/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/plugin/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/plugin/google/protobuf/compiler/plugin.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/retention/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/retention/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/retention/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/retention/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/retention/google/protobuf/compiler/retention.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/versions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/versions/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/versions/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/versions/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/_virtual_includes/versions/google/protobuf/compiler/versions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_objs/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_objs/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_objs/protoc-gen-cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field_chunk.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/ifndef_guard.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/message_layout_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/namespace_printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/padding_optimizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/parse_function_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/tracker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field_generators/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/cpp/google/protobuf/compiler/cpp/field_generators/generators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names/google/protobuf/compiler/cpp/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/_virtual_includes/names_internal/google/protobuf/compiler/cpp/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/src/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/cpp/protoc-gen-cpp.runfiles/protobuf+/src/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_objs/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_objs/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_doc_comment.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_field_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_reflection_class.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_source_generator_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/csharp/google/protobuf/compiler/csharp/csharp_wrapper_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/google/protobuf/compiler/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/csharp/_virtual_includes/names/google/protobuf/compiler/csharp/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/field_common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/internal_helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/java_features_bootstrap/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_objs/message_serialization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/context/google/protobuf/compiler/java/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/field_common/google/protobuf/compiler/java/field_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/protobuf/compiler/java/generator_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/generator_common/google/protobuf/compiler/java/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/doc_comment.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/name_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/helpers/google/protobuf/compiler/java/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/protobuf/compiler/java/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/internal_helpers/google/protobuf/compiler/java/internal_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/java_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java/google/protobuf/compiler/java/shared_code_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/java_features_bootstrap/google/protobuf/compiler/java/java_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/message_serialization/google/protobuf/compiler/java/message_serialization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names/google/protobuf/compiler/java/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/_virtual_includes/names_internal/google/protobuf/compiler/java/names_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/eg/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/fgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/mfg/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_objs/service/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/eg/google/protobuf/compiler/java/full/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fg/google/protobuf/compiler/java/full/field_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/fgs/google/protobuf/compiler/java/full/string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/full/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/full/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/full/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/full/google/protobuf/compiler/java/full/message_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/mfg/google/protobuf/compiler/java/full/make_field_gens.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/full/_virtual_includes/service/google/protobuf/compiler/java/full/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_objs/field_generators/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_objs/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/field_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/make_field_gens.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/field_generators/google/protobuf/compiler/java/lite/string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/java/lite/_virtual_includes/lite/google/protobuf/compiler/java/lite/message_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_objs/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_objs/kotlin_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/google/protobuf/compiler/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin/google/protobuf/compiler/kotlin/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/compiler/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/compiler/kotlin/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/compiler/kotlin/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/kotlin/_virtual_includes/kotlin_internal/google/protobuf/compiler/kotlin/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_objs/line_consumer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_objs/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_objs/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/line_consumer/google/protobuf/compiler/objectivec/line_consumer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names/google/protobuf/compiler/objectivec/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/protobuf/compiler/objectivec/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/names_internal/google/protobuf/compiler/objectivec/nsobject_methods.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/import_writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/oneof.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/objectivec/_virtual_includes/objectivec/google/protobuf/compiler/objectivec/tf_decode_data.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_objs/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_objs/php_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/google/protobuf/compiler/php/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/names/google/protobuf/compiler/php/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/google/protobuf/compiler/php/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/php/_virtual_includes/php_generator/google/protobuf/compiler/php/php_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/protobuf+/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/protobuf+/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/protobuf+/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/protoc_minimal.runfiles/protobuf+/src/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_objs/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/compiler/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/compiler/python/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/compiler/python/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/python/_virtual_includes/python/google/protobuf/compiler/python/pyi_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_objs/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/protobuf/compiler/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/protobuf/compiler/ruby/rbs_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/ruby/_virtual_includes/ruby/google/protobuf/compiler/ruby/ruby_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/context/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/crate_mapping/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/enum_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/message_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/naming/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/oneof/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/relative_path/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/rust_field_type/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/rust_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_objs/upb_helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/context/google/protobuf/compiler/rust/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/crate_mapping/google/protobuf/compiler/rust/crate_mapping.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/enum_stage1/google/protobuf/compiler/rust/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/message_stage1/google/protobuf/compiler/rust/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/protobuf/compiler/rust/naming.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/naming/google/protobuf/compiler/rust/rust_keywords.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/oneof/google/protobuf/compiler/rust/oneof.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/relative_path/google/protobuf/compiler/rust/relative_path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_field_type/google/protobuf/compiler/rust/rust_field_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/rust_stage1/google/protobuf/compiler/rust/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/_virtual_includes/upb_helpers/google/protobuf/compiler/rust/upb_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_objs/accessors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/accessor_case.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/accessors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/default_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/compiler/rust/accessors/_virtual_includes/accessors/google/protobuf/compiler/rust/accessors/with_presence.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/gzip_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/io_win32/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/printer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/tokenizer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_objs/zero_copy_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/gzip_stream/google/protobuf/io/gzip_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/coded_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io/google/protobuf/io/zero_copy_stream_impl_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/io_win32/google/protobuf/io/io_win32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/printer/google/protobuf/io/printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/strtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/tokenizer/google/protobuf/io/tokenizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/io/_virtual_includes/zero_copy_sink/google/protobuf/io/zero_copy_sink.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_objs/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/callback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/platform_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/src/google/protobuf/stubs/_virtual_includes/lite/google/protobuf/stubs/status_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_objs/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range_neon.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_range/utf8_range_sse.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_validity/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/third_party/utf8_range/_virtual_includes/utf8_validity/utf8_validity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/base/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/base/_objs/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/hash/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/hash/_objs/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mem/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mem/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mem/_objs/mem/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/_objs/copy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/_objs/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/_objs/iterator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/message/_objs/message/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_descriptor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_descriptor/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_descriptor/_objs/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_descriptor/_objs/mini_descriptor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_table/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_table/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_table/_objs/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/mini_table/_objs/mini_table/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/_objs/descriptor_upb_proto_minitable_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/_objs/descriptor_upb_proto_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/_objs/internal_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/_objs/internal_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/protobuf/descriptor.upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/protobuf/descriptor.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/protobuf/descriptor.upb_minitable.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/reflection/stage1/google/protobuf/descriptor.upb_minitable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/_objs/decoder/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/_objs/eps_copy_input_stream/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/_objs/reader/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/_objs/wire/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/decode_fast/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/decode_fast/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb/wire/decode_fast/_objs/select/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/common_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/common_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/file_layout_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/file_layout_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/plugin_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/plugin_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/plugin_upb_proto_minitable_stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/_objs/plugin_upb_proto_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/_objs/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/_objs/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/_objs/protoc-gen-upb_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/protoc-gen-upb_stage0.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/protoc-gen-upb_stage0.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/protoc-gen-upb_stage0.runfiles/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/protoc-gen-upb_stage0.runfiles/protobuf+/upb_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/c/protoc-gen-upb_stage0.runfiles/protobuf+/upb_generator/c/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/common/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/common/_objs/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/_objs/generator_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/_objs/names/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/_objs/names_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/_objs/protoc-gen-upb_minitable_stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/protoc-gen-upb_minitable_stage0.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/protoc-gen-upb_minitable_stage0.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/protoc-gen-upb_minitable_stage0.runfiles/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/protoc-gen-upb_minitable_stage0.runfiles/protobuf+/upb_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/minitable/protoc-gen-upb_minitable_stage0.runfiles/protobuf+/upb_generator/minitable/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/compiler/plugin.upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/compiler/plugin.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/compiler/plugin.upb_minitable.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/protobuf+/upb_generator/stage1/google/protobuf/compiler/plugin.upb_minitable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_cc+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_fuzzing+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_fuzzing+/fuzzing/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_fuzzing+/fuzzing/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/flags/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/logging/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl_py-2.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/Python.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bltinmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/boolobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bytearrayobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/codecs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/complexobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/datetime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/descrobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/dictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/dynamic_annotations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/enumobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/errcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/exports.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/fileobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/frameobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/genericaliasobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/intrcheck.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/iterobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/listobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/longobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/marshal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/memoryobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/methodobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/modsupport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/moduleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/objimpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/opcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/osdefs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/osmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/patchlevel.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/py_curses.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pybuffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pycapsule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pydtrace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyexpat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyframe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymacconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymacro.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystrcmp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystrtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pythonrun.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pythread.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pytypedefs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/rangeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/setobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/sliceobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/structmember.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/structseq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/token.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/tracemalloc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/tupleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/typeslots.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/weakrefobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/bytearrayobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/cellobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/classobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/complexobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/descrobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/dictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/fileobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/frameobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/funcobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/genobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/initconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/listobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/longintrepr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/longobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/methodobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/modsupport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/objimpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/odictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/picklebufobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pthread_stubs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyctype.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pydebug.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyfpe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyframe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pythonrun.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pythread.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pytime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/setobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/tupleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/weakrefobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_accu.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_asdl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ast_state.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_atomic.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_atomic_funcs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bitutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_blocks_output_buffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bytes_methods.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_call.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_condvar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_dict.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_dtoa.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_emscripten_signal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_exceptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_frame.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_gc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_genobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_getopt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_gil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_global_objects.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_global_strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_hamt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_hashtable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_initconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_interp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_interpreteridobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_list.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_long.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_moduleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_namespace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_opcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pathconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyarena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pymath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_runtime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_runtime_init.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_signal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_sliceobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_strhex.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_structseq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_symtable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_tuple.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_typeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ucnhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_unionobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/itcl4.2.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/pkgconfig/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/__phello__/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/asyncio/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/futures/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/config-3.11-x86_64-linux-gnu/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/config-3.11-x86_64-linux-gnu/config.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ctypes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ctypes/macholib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/curses/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/dbm/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/distutils/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/email/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/email/mime/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/encodings/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ensurepip/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ensurepip/_bundled/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/html/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/http/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/idlelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/idlelib/Icons/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib-dynload/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/fixes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/pgen2/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/multiprocessing/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/multiprocessing/dummy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/pydoc_data/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/re/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/_distutils_hack/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip-24.3.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/cli/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/commands/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/distributions/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/index/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/locations/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/metadata/importlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/models/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/network/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/build/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/install/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/req/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/legacy/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/utils/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/vcs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/cachecontrol/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/cachecontrol/caches/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/certifi/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/distlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/distro/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/idna/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/msgpack/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pkg_resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/platformdirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/filters/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/lexers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/styles/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pyproject_hooks/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pyproject_hooks/_in_process/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/requests/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/resolvelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/resolvelib/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/rich/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/tomli/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/truststore/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/_securetransport/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/packages/backports/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools-80.9.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools-80.9.0.dist-info/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compilers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compilers/C/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/autocommand/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/tarfile/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/tarfile/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/functools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/text/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/more_itertools/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging-24.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/tomli/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typeguard/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel-0.45.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/cli/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/vendored/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/vendored/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/config/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/sqlite3/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/tkinter/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/tomllib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/turtledemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/unittest/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/urllib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/posix/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/wsgiref/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/dom/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/etree/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/parsers/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/sax/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xmlrpc/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/zoneinfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/tclAppInit.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/encoding/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/http1.0/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/msgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/opt0.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.4/platform/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.5/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/thread2.8.9/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/tkAppInit.c
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/demos/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/demos/images/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/images/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/msgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/ttk/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/man/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_fuzzing+/fuzzing/tools/make_corpus_dir.runfiles/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/man/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_java+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_java+/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/rules_java+/toolchains/platformclasspath_classes/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/_objs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/_objs/z/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/crc32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/deflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/gzguts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/inffast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/inffixed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/inflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/inftrees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/trees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/zconf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/zlib.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt-exec-ST-d57f47055a04/bin/external/zlib+/zlib/include/zutil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/bin/fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/bin/fuzz/fuzz_eval_corpus/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/bin/fuzz/fuzz_parse_corpus/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel-out/k8-opt/testlogs/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel/cat_param_file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": bazel/cel_cc_embed.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/checker_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/optional.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/optional.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/optional_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/standard_library.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/standard_library.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/standard_library_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_check_issue.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_check_issue.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_check_issue_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_builder_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_builder_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_builder_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_subset_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_subset_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/type_checker_subset_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/validation_result.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/validation_result.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/validation_result_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/builtins_arena.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/builtins_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/descriptor_pool_type_introspector.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/descriptor_pool_type_introspector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/descriptor_pool_type_introspector_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/field_path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/field_path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/field_path_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/namespace_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/namespace_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/namespace_generator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/proto_type_mask_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/test_ast_helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/test_ast_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/test_ast_helpers_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_check_env.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_check_env.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_builder_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_builder_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_builder_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_checker_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_inference_context.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_inference_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": checker/internal/type_inference_context_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/cel_compiler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/cel_compiler_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise1.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise1.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise10.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise10.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise10_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise1_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise2_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise3_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise4.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise4.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/exercise4_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/network_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/network_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/network_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/exercise1.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/exercise10.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/exercise2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/exercise3_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": codelab/solutions/exercise4.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/
Step #3 - "compile-libfuzzer-coverage-x86_64": common/allocator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/allocator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/any.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/any_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string_view.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/arena_string_view_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_rewrite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_rewrite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_rewrite_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_traverse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_traverse.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_traverse_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast_visitor_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/casting.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/constant.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/constant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/constant_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/container.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/container_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/data.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/data_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_proto_v1alpha1.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_proto_v1alpha1.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/decl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/expr.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/expr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/expr_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/expr_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/format_type_name.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/format_type_name.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/format_type_name_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/function_descriptor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/function_descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/json.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/kind.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/kind.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/kind_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/legacy_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/legacy_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/memory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/memory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/memory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/memory_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_database.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_database_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/minimal_descriptor_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/native_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/navigable_ast.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/navigable_ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/navigable_ast_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/operators.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/operators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/optional_ref.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/reference.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/reference.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/reference_count.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/reference_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/source.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/source.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/source_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/standard_definitions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_introspector.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_introspector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_kind.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_reflector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_reflector_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_spec_resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_spec_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_spec_resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/type_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/typeinfo.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/typeinfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/typeinfo_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/unknown.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value_kind.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value_testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/value_testing_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/constant_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/constant_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/expr_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/expr_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/expr_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/metadata.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/metadata_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/navigable_ast_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/navigable_ast_internal_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/navigable_ast_kinds.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/navigable_ast_kinds.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/source_info_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/ast/source_info_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/byte_string.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/byte_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/byte_string_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/casting.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/reference_count.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/reference_count.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/reference_count_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/signature.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/signature.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/signature_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/value_conversion.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/internal/value_conversion.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/any_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/any_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/basic_struct_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/basic_struct_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/basic_struct_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bool_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bool_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bool_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bool_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bytes_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bytes_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bytes_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/bytes_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/double_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/double_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/double_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/double_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/duration_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/duration_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/dyn_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/dyn_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/enum_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/enum_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/enum_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/error_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/error_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/function_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/function_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/function_type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/function_type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/function_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/int_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/int_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/int_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/int_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/legacy_type_introspector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/list_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/list_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/list_type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/list_type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/list_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/map_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/map_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/map_type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/map_type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/map_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/message_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/message_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/message_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/null_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/null_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/opaque_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/opaque_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/opaque_type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/opaque_type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/opaque_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/optional_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/optional_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/optional_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/string_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/string_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/string_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/string_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/struct_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/struct_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/struct_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/timestamp_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/timestamp_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_param_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_param_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_type_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_type_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/type_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/uint_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/uint_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/uint_wrapper_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/uint_wrapper_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/unknown_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/types/unknown_type_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bool_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bool_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bool_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bytes_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bytes_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bytes_value_input_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bytes_value_output_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/bytes_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_list_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_list_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_list_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_map_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_map_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_map_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_struct_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_struct_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_struct_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/custom_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/double_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/double_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/double_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/duration_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/duration_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/duration_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/enum_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/error_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/error_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/error_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/int_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/int_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/int_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_list_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_list_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_map_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_map_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_struct_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/legacy_struct_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/list_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/list_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/list_value_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/list_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/list_value_variant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/map_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/map_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/map_value_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/map_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/map_value_variant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/message_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/message_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/message_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/mutable_list_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/mutable_map_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/null_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/null_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/null_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/opaque_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/opaque_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/optional_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/optional_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/optional_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_list_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_list_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_list_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_map_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_map_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_map_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_json_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_map_field_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_map_field_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_map_field_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_message_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_message_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_message_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_repeated_field_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_repeated_field_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/parsed_repeated_field_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/string_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/string_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/string_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/struct_value_variant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/timestamp_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/timestamp_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/timestamp_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/type_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/type_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/type_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/uint_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/uint_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/uint_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/unknown_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/unknown_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/unknown_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/value_variant_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": common/values/values.h
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_library_subset_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_library_subset_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/compiler_library_subset_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/optional.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/optional.h
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/optional_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/standard_library.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": compiler/standard_library.h
Step #3 - "compile-libfuzzer-coverage-x86_64": conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": conformance/run.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": conformance/service.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": conformance/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": conformance/utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/
Step #3 - "compile-libfuzzer-coverage-x86_64": env/config.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/config_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_runtime.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_runtime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_runtime_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_std_extensions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_std_extensions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_std_extensions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_yaml.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_yaml.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/env_yaml_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/runtime_std_extensions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/runtime_std_extensions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/runtime_std_extensions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/type_info.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/type_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/type_info_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/ext_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/ext_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/ext_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/runtime_ext_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/runtime_ext_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": env/internal/runtime_ext_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/cel_expression_builder_flat_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/cel_expression_builder_flat_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/cel_expression_builder_flat_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/check_ast_extensions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/check_ast_extensions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/check_ast_extensions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/comprehension_vulnerability_check.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/comprehension_vulnerability_check.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/constant_folding.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/constant_folding.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/constant_folding_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_comprehensions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_extensions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_extensions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_extensions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_short_circuiting_conformance_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/flat_expr_builder_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/instrumentation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/instrumentation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/instrumentation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/qualified_reference_resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/qualified_reference_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/qualified_reference_resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/regex_precompilation_optimization.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/regex_precompilation_optimization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/regex_precompilation_optimization_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/compiler/resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_trail.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_trail.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_trail_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_utility.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_utility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/attribute_utility_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/cel_expression_flat_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/cel_expression_flat_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/compiler_constant_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/compiler_constant_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/compiler_constant_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/comprehension_slots.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/comprehension_slots_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/comprehension_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/comprehension_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/comprehension_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/const_value_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/container_access_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/container_access_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/container_access_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_list_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_list_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_list_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_map_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_map_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_map_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_struct_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_struct_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/create_struct_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/direct_expression_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/direct_expression_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/equality_steps.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/equality_steps.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/equality_steps_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_core.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_core.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_core_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_stack.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_stack.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/evaluator_stack_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/expression_step_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/function_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/function_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/function_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ident_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ident_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ident_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/iterator_stack.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/jump_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/jump_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/lazy_init_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/lazy_init_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/lazy_init_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/logic_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/logic_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/logic_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/optional_or_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/optional_or_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/optional_or_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/regex_match_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/regex_match_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/regex_match_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/select_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/select_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/select_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/shadowable_value_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/shadowable_value_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/shadowable_value_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ternary_step.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ternary_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/ternary_step_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/eval/trace_step.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/adapter_activation_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/adapter_activation_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/cel_value_equal.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/cel_value_equal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/cel_value_equal_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/errors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/errors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/internal/interop.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation_bind_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation_bind_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation_bind_helper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/activation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_rewrite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_rewrite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_rewrite_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_traverse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_traverse.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_traverse_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/ast_visitor_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/base_activation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/builtin_func_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/builtin_func_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/builtin_func_registrar_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/builtin_func_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_attribute.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_attribute.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_attribute_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_builtins.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_expr_builder_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_expr_builder_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_expression.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_adapter_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_adapter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_function_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_number.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_number.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_number_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_options.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_type_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_type_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_type_registry_protobuf_reflection_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_type_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_value_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_value_producer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/cel_value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/comparison_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/comparison_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/comparison_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/container_function_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/container_function_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/container_function_registrar_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/equality_function_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/equality_function_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/equality_function_registrar_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/extension_func_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/extension_func_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/extension_func_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/logical_function_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/logical_function_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/logical_function_registrar_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/message_wrapper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/message_wrapper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/portable_cel_function_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/set_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/set_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/set_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/source_position.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/source_position.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/source_position_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/string_extension_func_registrar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/string_extension_func_registrar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/string_extension_func_registrar_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/transform_utility.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/transform_utility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_attribute_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_attribute_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_function_result_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_function_result_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_function_result_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/unknown_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/value_export_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/value_export_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/value_export_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/container_backed_list_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/container_backed_map_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/container_backed_map_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/container_backed_map_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_access.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_access.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_access_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_backed_list_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_backed_list_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_backed_map_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/field_backed_map_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_list_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_list_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_list_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_map_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_map_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/containers/internal_field_backed_map_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_descriptor_pool_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_descriptor_pool_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_descriptor_pool_builder_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrap_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrap_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrap_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrapper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrapper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/cel_proto_wrapper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/dynamic_descriptor_pool_end_to_end_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/field_access_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/field_access_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/field_access_impl_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/field_access_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_adapter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_info_apis.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_provider.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/legacy_type_provider_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/proto_message_type_adapter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/proto_message_type_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/proto_message_type_adapter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/protobuf_descriptor_type_provider.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/protobuf_descriptor_type_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/protobuf_descriptor_type_provider_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/protobuf_value_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/trivial_legacy_type_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/structs/trivial_legacy_type_info_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/testing/matchers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/testing/matchers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/public/testing/matchers_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/allocation_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/end_to_end_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/expression_builder_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/memory_safety_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/mock_cel_expression.h
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/modern_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/tests/unknowns_end_to_end_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": eval/testutil/
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/bindings_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/bindings_ext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/bindings_ext_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/bindings_ext_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2_macros.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/comprehensions_v2_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/encoders.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/encoders.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/encoders_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/formatting.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/formatting.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/formatting_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/lists_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/lists_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/lists_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext_decls.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext_decls.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext_macros.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/math_ext_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/proto_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/proto_ext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_ext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_ext_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/regex_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/select_optimization.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/select_optimization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/select_optimization_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/sets_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/sets_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/sets_functions_benchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/sets_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/strings_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/ast_converters.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/bind_proto_to_activation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/bind_proto_to_activation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/bind_proto_to_activation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/enum_adapter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/enum_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/memory_manager.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/memory_manager.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/memory_manager_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/runtime_adapter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/runtime_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/value_end_to_end_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/value_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/value_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/value_testing_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/internal/map_reflection.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/internal/map_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/internal/qualify.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": extensions/protobuf/internal/qualify.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/+_repo_rules+antlr4_jar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/+_repo_rules+antlr4_jar/jar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/.github/ISSUE_TEMPLATE/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/CMake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/CMake/Googletest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/CMake/install_test_project/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/CMake/install_test_project/simple.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/algorithm/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/algorithm/algorithm.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/algorithm/algorithm_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/algorithm/container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/algorithm/container_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/attributes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/attributes_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/bit_cast_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/c_header_test.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/call_once.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/call_once_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/casts.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/casts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/casts_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/config_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/const_init.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/dynamic_annotations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/exception_safety_testing_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/fast_type_id.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/fast_type_id_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/log_severity.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/log_severity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/log_severity_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/no_destructor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/no_destructor_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/no_destructor_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/nullability.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/nullability_default_nonnull_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/nullability_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/optimization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/optimization_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/policy_checks.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/prefetch.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/prefetch_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/raw_logging_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/spinlock_test_common.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/thread_annotations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/throw_delegate_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/atomic_hook.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/atomic_hook_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/atomic_hook_test_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/atomic_hook_test_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/cmake_thread_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/cycleclock.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/cycleclock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/cycleclock_config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/direct_mmap.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/dynamic_annotations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/endian_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/errno_saver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/errno_saver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/exception_safety_testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/exception_safety_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/exception_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/hide_ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/iterator_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/iterator_traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/iterator_traits_test_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/low_level_alloc.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/low_level_alloc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/low_level_alloc_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/low_level_scheduling.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/nullability_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/nullability_traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/per_thread_tls.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/poison.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/poison.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/poison_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/pretty_function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/raw_logging.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/raw_logging.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/scheduling_mode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/scoped_set_env.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/scoped_set_env.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/scoped_set_env_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_akaros.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_linux.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_posix.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_wait.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_wait.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/spinlock_win32.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/strerror.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/strerror.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/strerror_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/strerror_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/sysinfo.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/sysinfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/sysinfo_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/thread_identity.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/thread_identity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/thread_identity_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/thread_identity_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/throw_delegate.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/throw_delegate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/tracing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/tracing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/tracing_strong_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/tracing_weak_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/tsan_mutex_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/unaligned_access.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/unique_small_name_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/unscaledcycleclock.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/unscaledcycleclock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/base/internal/unscaledcycleclock_config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/cleanup/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/cleanup/cleanup.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/cleanup/cleanup_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/cleanup/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/cleanup/internal/cleanup.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/btree_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/btree_map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/btree_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/btree_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/btree_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/chunked_queue.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/chunked_queue_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/chunked_queue_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/fixed_array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/fixed_array_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/fixed_array_exception_safety_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/fixed_array_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/flat_hash_map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/flat_hash_map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/flat_hash_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/flat_hash_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/hash_container_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/inlined_vector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/inlined_vector_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/inlined_vector_exception_safety_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/inlined_vector_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_map_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_set_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/linked_hash_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/node_hash_map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/node_hash_map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/node_hash_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/node_hash_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/sample_element_size_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/btree.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/btree_container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/chunked_queue.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/common_policy_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/common_policy_traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/compressed_tuple.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/compressed_tuple_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/container_memory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/container_memory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_function_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_function_defaults_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_generator_testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_generator_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_policy_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_policy_testing_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_policy_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hash_policy_traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtable_control_bytes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtable_control_bytes_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtable_debug.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtable_debug_hooks.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtablez_sampler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtablez_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtablez_sampler_force_weak_definition.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/hashtablez_sampler_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/heterogeneous_lookup_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/inlined_vector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/layout.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/layout_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/layout_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/node_slot_policy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/node_slot_policy_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_allocator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_probe_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_resize_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_resize_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/raw_hash_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/test_allocator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/test_instance_tracker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/test_instance_tracker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/test_instance_tracker_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/tracked.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_map_constructor_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_map_lookup_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_map_members_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_map_modifiers_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_set_constructor_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_set_lookup_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_set_members_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_set_modifiers_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/container/internal/unordered_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/copts/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/crc32c.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/crc32c.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/crc32c_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/crc32c_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/cpu_detect.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/cpu_detect.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc32_x86_arm_combined_simd.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc32c.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc32c_inline.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_cord_state.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_cord_state.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_cord_state_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_memcpy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_memcpy_fallback.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_memcpy_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_memcpy_x86_arm_combined.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_non_temporal_memcpy.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/crc_x86_arm_combined.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/non_temporal_arm_intrinsics.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/non_temporal_memcpy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/crc/internal/non_temporal_memcpy_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/failure_signal_handler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/failure_signal_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/failure_signal_handler_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/leak_check.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/leak_check.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/leak_check_fail_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/leak_check_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/stacktrace.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/stacktrace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/stacktrace_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/stacktrace_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_darwin.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_elf.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_emscripten.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_unimplemented.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/symbolize_win32.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/address_is_readable.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/address_is_readable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/addresses.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/borrowed_fixup_buffer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/borrowed_fixup_buffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/borrowed_fixup_buffer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/bounded_utf8_length_sequence.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/bounded_utf8_length_sequence_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/decode_rust_punycode.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/decode_rust_punycode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/decode_rust_punycode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle_rust.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle_rust.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle_rust_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/demangle_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/elf_mem_image.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/elf_mem_image.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/examine_stack.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/examine_stack.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stack_consumption.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stack_consumption.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stack_consumption_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_aarch64-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_arm-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_emscripten-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_generic-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_powerpc-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_riscv-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_unimplemented-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_win32-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/stacktrace_x86-inl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/symbolize.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/utf8_for_code_point.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/utf8_for_code_point.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/utf8_for_code_point_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/vdso_support.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/debugging/internal/vdso_support.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/commandlineflag.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/commandlineflag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/commandlineflag_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/config_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/declare.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/flag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/flag_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/flag_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/flag_test_defs.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/marshalling.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/marshalling.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/marshalling_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/parse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/parse.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/parse_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/reflection.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/reflection_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/usage.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/usage.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/usage_config.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/usage_config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/usage_config_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/commandlineflag.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/commandlineflag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/flag.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/flag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/parse.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/path_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/path_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/private_handle_accessor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/private_handle_accessor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/program_name.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/program_name.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/program_name_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/sequence_lock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/sequence_lock_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/usage.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/usage.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/flags/internal/usage_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/any_invocable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/any_invocable_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/bind_front.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/bind_front_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/function_ref.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/function_ref_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/function_type_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/overload.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/overload_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/internal/any_invocable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/internal/front_binder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/functional/internal/function_ref.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/hash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/hash_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/hash_instantiated_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/hash_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/hash_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/city.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/city.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/city_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/hash.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/hash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/hash_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/low_level_hash_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/print_hash_of.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/spy_hash_state.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/hash/internal/weakly_mixed_integer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/absl_check.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/absl_check_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/absl_log.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/absl_log_basic_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/absl_vlog_is_on.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/check.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/check_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/check_test_impl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/die_if_null.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/die_if_null.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/die_if_null_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/flags.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/flags.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/flags_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/globals.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/globals.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/globals_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/initialize.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/initialize.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_basic_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_basic_test_impl.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_entry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_entry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_format_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_macro_hygiene_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_modifier_methods_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_sink.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_sink.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_sink_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_sink_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_streamer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/log_streamer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/scoped_mock_log.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/scoped_mock_log.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/scoped_mock_log_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/stripping_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/structured.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/structured_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/vlog_is_on.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/vlog_is_on_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/append_truncated.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/check_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/check_op.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/check_op.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/conditions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/conditions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/container_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/flags.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/fnmatch.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/fnmatch.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/fnmatch_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/fnmatch_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/globals.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/globals.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_format.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_sink_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/log_sink_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/nullguard.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/nullguard.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/nullstream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/stderr_log_sink_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/strip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/structured.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/structured_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/structured_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/structured_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_actions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_actions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_matchers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/test_matchers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/vlog_config.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/vlog_config.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/vlog_config_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/log/internal/voidify.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/memory/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/memory/memory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/memory/memory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/type_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/type_traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/internal/constexpr_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/internal/constexpr_testing_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/internal/requires.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/meta/internal/requires_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/bits_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/bits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128_have_intrinsic.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128_no_intrinsic.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128_stream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/int128_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/internal/bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/numeric/internal/representation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/hashtable.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/hashtable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/exponential_biased.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/exponential_biased.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/exponential_biased_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/periodic_sampler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/periodic_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/periodic_sampler_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/periodic_sampler_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/profile_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/profile_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/sample_recorder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/profiling/internal/sample_recorder_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/benchmarks.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/bernoulli_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/bernoulli_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/beta_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/beta_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/bit_gen_ref.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/bit_gen_ref_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/discrete_distribution.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/discrete_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/discrete_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/distributions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/distributions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/examples_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/exponential_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/exponential_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/gaussian_distribution.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/gaussian_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/gaussian_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/generators_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/log_uniform_int_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/log_uniform_int_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/mock_distributions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/mock_distributions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/mocking_bit_gen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/mocking_bit_gen_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/poisson_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/poisson_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/random.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/seed_gen_exception.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/seed_gen_exception.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/seed_sequences.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/seed_sequences.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/seed_sequences_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/uniform_int_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/uniform_int_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/uniform_real_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/uniform_real_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/zipf_distribution.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/zipf_distribution_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/chi_square.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/chi_square.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/chi_square_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/distribution_caller.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/distribution_test_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/distribution_test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/distribution_test_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/entropy_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/entropy_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/entropy_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/explicit_seed_seq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/explicit_seed_seq_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/fast_uniform_bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/fast_uniform_bits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/fastmath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/fastmath_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/gaussian_distribution_gentables.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/generate_real.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/generate_real_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/iostream_state_saver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/iostream_state_saver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/mock_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/mock_overload_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/mock_validators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/nanobenchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/nanobenchmark.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/nanobenchmark_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/nonsecure_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/nonsecure_base_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/pcg_engine.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/pcg_engine_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_benchmarks.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_detect.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_detect.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_engine.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_engine_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_hwaes.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_hwaes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_hwaes_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_round_keys.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_slow.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_slow.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_slow_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/randen_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/salted_seed_seq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/salted_seed_seq_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/seed_material.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/seed_material.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/seed_material_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/sequence_urbg.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/traits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/uniform_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/uniform_helper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/wide_multiply.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/random/internal/wide_multiply_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_matchers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_matchers_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_payload_printer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_payload_printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/status_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/statusor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/statusor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/statusor_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/statusor_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/status_internal.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/status_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/status_matchers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/status_matchers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/status/internal/statusor_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/ascii.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/ascii.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/ascii_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/ascii_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/atod_manual_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/char_formatting_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charconv.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charconv.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charconv_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charconv_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charset.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charset_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/charset_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_analysis.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_analysis.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_buffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_buffer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cord_test_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cordz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/cordz_test_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/escaping.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/escaping.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/escaping_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/escaping_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/has_absl_stringify.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/has_absl_stringify_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/has_ostream_operator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/has_ostream_operator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/match.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/match.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/match_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/numbers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/numbers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/numbers_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/numbers_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/resize_and_overwrite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/resize_and_overwrite_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_cat.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_cat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_cat_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_cat_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_format_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_join.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_join_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_join_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_replace.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_replace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_replace_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_replace_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_split.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_split.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_split_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/str_split_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/string_view.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/string_view_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/strip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/strip_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/substitute.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/substitute.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/substitute_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/substitute_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/append_and_overwrite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/append_and_overwrite_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_bigint.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_bigint.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_bigint_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_parse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_parse.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/charconv_parse_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_data_edge.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_data_edge_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_internal.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_navigator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_navigator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_navigator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_reader.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_reader.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_reader_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_btree_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_consume.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_consume.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_crc.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_crc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_crc_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_flat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cord_rep_test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_handle.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_handle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_handle_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_info.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_info_statistics_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_info_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_sample_token.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_sample_token.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_sample_token_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_statistics.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_update_scope.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_update_scope_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_update_tracker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/cordz_update_tracker_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/damerau_levenshtein_distance.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/damerau_levenshtein_distance.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/damerau_levenshtein_distance_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/damerau_levenshtein_distance_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/escaping.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/escaping.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/escaping_test_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/generic_printer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/generic_printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/generic_printer_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/generic_printer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/memutil.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/memutil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/memutil_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/memutil_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/numbers_test_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/ostringstream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/ostringstream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/ostringstream_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/ostringstream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/pow10_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/pow10_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/pow10_helper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/resize_uninitialized.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/resize_uninitialized_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/stl_type_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_join_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_split_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/string_constant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/string_constant_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/stringify_sink.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/stringify_sink.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/utf8.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/utf8.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/utf8_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/arg.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/arg.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/arg_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/bind.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/bind.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/bind_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/checker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/checker_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/constexpr_parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/convert_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/extension_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/float_conversion.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/float_conversion.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/output.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/output.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/output_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/strings/internal/str_format/parser_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/barrier.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/barrier.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/barrier_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/blocking_counter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/blocking_counter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/blocking_counter_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/blocking_counter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/lifetime_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex_method_pointer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/mutex_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/notification.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/notification.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/notification_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/create_thread_identity.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/create_thread_identity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/futex.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/futex_waiter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/futex_waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/graphcycles.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/graphcycles.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/graphcycles_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/graphcycles_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/kernel_timeout.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/kernel_timeout.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/kernel_timeout_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/per_thread_sem.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/per_thread_sem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/per_thread_sem_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/pthread_waiter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/pthread_waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/sem_waiter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/sem_waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/stdcpp_waiter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/stdcpp_waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/thread_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/waiter_base.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/waiter_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/waiter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/win32_waiter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/synchronization/internal/win32_waiter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/civil_time.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/civil_time.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/civil_time_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/civil_time_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/clock.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/clock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/clock_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/clock_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/duration.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/duration_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/duration_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/flag_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/format.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/format_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/format_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/time.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/time.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/time_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/time_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/time_zone_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/get_current_time_chrono.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/get_current_time_posix.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/test_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/cctz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/cctz/civil_time.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/cctz/civil_time_detail.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/cctz/time_zone.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/include/cctz/zone_info_source.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/cctz_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/civil_time_detail.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/civil_time_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/test_time_zone_names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/test_time_zone_names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_fixed.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_fixed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_format.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_format_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_if.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_if.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_info.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_libc.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_libc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_lookup.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_lookup_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_name_win.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_name_win.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/time_zone_posix.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/tzfile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/src/zone_info_source.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Africa/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/America/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Arctic/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Asia/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Australia/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Brazil/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Canada/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Chile/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Etc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Europe/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Indian/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Mexico/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/Pacific/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/time/internal/cctz/testdata/zoneinfo/US/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/compare.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/compare_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/optional.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/span.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/span_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/variant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/variant_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/types/internal/span.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/utility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/absl/utility/utility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/ci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/abseil-cpp+/ci/absl_alternate_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Linux/main.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlr4-cpp-demo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlr4-cpp-demo/main.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp Tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp-demo.xcodeproj/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Windows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Windows/antlr4-cpp-demo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/demo/Windows/antlr4-cpp-demo/main.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp-ios/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp-ios/antlrcpp_ios.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp.xcodeproj/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp.xcodeproj/project.xcworkspace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp.xcodeproj/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/nuget/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRErrorStrategy.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRErrorStrategy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRFileStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRFileStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRInputStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ANTLRInputStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BailErrorStrategy.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BailErrorStrategy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BaseErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BaseErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BufferedTokenStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/BufferedTokenStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CharStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CharStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonToken.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonToken.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonTokenFactory.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonTokenFactory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonTokenStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/CommonTokenStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ConsoleErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ConsoleErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/DefaultErrorStrategy.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/DefaultErrorStrategy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/DiagnosticErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/DiagnosticErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Exceptions.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Exceptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/FailedPredicateException.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/FailedPredicateException.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/FlatHashMap.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/FlatHashSet.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/InputMismatchException.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/InputMismatchException.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/IntStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/IntStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/InterpreterRuleContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/InterpreterRuleContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Lexer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Lexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/LexerInterpreter.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/LexerInterpreter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/LexerNoViableAltException.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/LexerNoViableAltException.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ListTokenSource.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ListTokenSource.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/NoViableAltException.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/NoViableAltException.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Parser.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ParserInterpreter.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ParserInterpreter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ParserRuleContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ParserRuleContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ProxyErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/ProxyErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RecognitionException.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RecognitionException.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Recognizer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Recognizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuleContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuleContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuleContextWithAltNum.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuleContextWithAltNum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuntimeMetaData.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/RuntimeMetaData.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Token.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Token.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenFactory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenSource.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenSource.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenStreamRewriter.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/TokenStreamRewriter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/UnbufferedCharStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/UnbufferedCharStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/UnbufferedTokenStream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/UnbufferedTokenStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Vocabulary.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/Vocabulary.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/WritableToken.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/WritableToken.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/antlr4-common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/antlr4-runtime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATN.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATN.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNConfig.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNConfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNConfigSet.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNConfigSet.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNDeserializationOptions.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNDeserializationOptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNDeserializer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNDeserializer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNSimulator.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNSimulator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNState.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNStateType.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNStateType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ATNType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ActionTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ActionTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/AmbiguityInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/AmbiguityInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ArrayPredictionContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ArrayPredictionContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/AtomTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/AtomTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/BasicBlockStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/BasicState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/BlockEndState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/BlockStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ContextSensitivityInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ContextSensitivityInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionEventInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionEventInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionState.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/DecisionState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/EpsilonTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/EpsilonTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ErrorInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ErrorInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/HashUtils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LL1Analyzer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LL1Analyzer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerATNConfig.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerATNConfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerATNSimulator.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerATNSimulator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerActionExecutor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerActionExecutor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerActionType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerChannelAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerChannelAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerCustomAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerCustomAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerIndexedCustomAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerIndexedCustomAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerModeAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerModeAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerMoreAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerMoreAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerPopModeAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerPopModeAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerPushModeAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerPushModeAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerSkipAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerSkipAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerTypeAction.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LexerTypeAction.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LookaheadEventInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LookaheadEventInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/LoopEndState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/NotSetTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/NotSetTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/OrderedATNConfigSet.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/OrderedATNConfigSet.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ParseInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ParseInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ParserATNSimulator.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ParserATNSimulator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ParserATNSimulatorOptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PlusBlockStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PlusLoopbackState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PrecedencePredicateTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PrecedencePredicateTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredicateEvalInfo.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredicateEvalInfo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredicateTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredicateTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextCache.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextCache.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextMergeCache.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextMergeCache.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextMergeCacheOptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionContextType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionMode.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/PredictionMode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ProfilingATNSimulator.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/ProfilingATNSimulator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RangeTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RangeTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RuleStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RuleStopState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RuleTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/RuleTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SemanticContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SemanticContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SemanticContextType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SerializedATNView.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SetTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SetTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SingletonPredictionContext.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/SingletonPredictionContext.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/StarBlockStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/StarLoopEntryState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/StarLoopbackState.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/StarLoopbackState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/TokensStartState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/Transition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/Transition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/TransitionType.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/TransitionType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/WildcardTransition.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/atn/WildcardTransition.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFA.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFA.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFASerializer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFASerializer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFAState.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/DFAState.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/LexerDFASerializer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/dfa/LexerDFASerializer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/internal/Synchronization.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/internal/Synchronization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/InterpreterDataReader.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/InterpreterDataReader.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/Interval.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/Interval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/IntervalSet.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/IntervalSet.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/MurmurHash.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/MurmurHash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/Predicate.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/misc/Predicate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Any.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Arrays.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Arrays.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/BitSet.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/CPPUtils.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/CPPUtils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Casts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Declarations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/StringUtils.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/StringUtils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Unicode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Utf8.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/support/Utf8.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/AbstractParseTreeVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ErrorNode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ErrorNodeImpl.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ErrorNodeImpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/IterativeParseTreeWalker.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/IterativeParseTreeWalker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTree.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTree.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeProperty.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeType.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeVisitor.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeVisitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeWalker.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/ParseTreeWalker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/TerminalNode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/TerminalNodeImpl.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/TerminalNodeImpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/Trees.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/Trees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/Chunk.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/Chunk.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreeMatch.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreeMatch.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreePattern.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreePattern.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreePatternMatcher.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/ParseTreePatternMatcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/RuleTagToken.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/RuleTagToken.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TagChunk.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TagChunk.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TextChunk.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TextChunk.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TokenTagToken.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/pattern/TokenTagToken.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPath.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathLexer.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathLexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathLexerErrorListener.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathLexerErrorListener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathRuleAnywhereElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathRuleAnywhereElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathRuleElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathRuleElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathTokenAnywhereElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathTokenAnywhereElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathTokenElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathTokenElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathWildcardAnywhereElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathWildcardAnywhereElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathWildcardElement.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/src/tree/xpath/XPathWildcardElement.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/antlr4-cpp-runtime+/runtime/tests/Utf8Test.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools+xcode_configure_extension+local_config_xcode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/sdp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/security/policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/security/policy/limited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/conf/security/policy/unlimited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/classfile_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/jni.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/jvmti.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/jvmticmlr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/include/linux/jni_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.instrument/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.naming/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.security.sasl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.sql/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.transaction.xa/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/java.xml/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/jdk.crypto.ec/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/jdk.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/legal/jdk.unsupported/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/lib/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/jdk/lib/server/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/conditions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/google/devtools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/google/devtools/build/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/google/devtools/build/buildjar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/buildjar/java/com/google/devtools/build/buildjar/jarhelper/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/com/google/devtools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/com/google/devtools/build/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/java_tools/import_deps_checker/java/com/google/devtools/build/importdeps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/bazel_log_handler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/bazel_log_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/errors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/errors_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/errors_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/exit_code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/file_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/file_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/file_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/logging.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/logging.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/md5.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/md5.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/numbers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/numbers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/path_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/path_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/path_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/port.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/cpp/util/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/file-jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/jni-util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/jni-util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/process.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/process.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/processes-jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/sleep_prevention_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_cpu_speed_monitor_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_disk_space_monitor_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_load_advisory_monitor_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_memory_pressure_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_network_stats.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_suspension_monitor_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/system_thermal_monitor_jni.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/native/windows/util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/main/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/bash_launcher.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/bash_launcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/dummy.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/java_launcher.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/java_launcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/launcher.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/launcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/launcher_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/launcher_maker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/launcher_maker_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/python_launcher.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/python_launcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/data_parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/data_parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/data_parser_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/dummy.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/launcher_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/launcher_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/src/tools/launcher/util/launcher_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/def_parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/def_parser/def_parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/def_parser/def_parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/def_parser/def_parser_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/grpc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/grpc/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/mapped_file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/mapped_file_unix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/platform_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/platform_utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/zip.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/zip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/zip_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/zlib_client.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/ijar/zlib_client.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/java/j2objc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/absl/logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/absl/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/abseil/absl_py.egg-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/six/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/third_party/py/six/documentation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/config_feature_flag/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/dormant_dependency_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/extend_rule_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/function_transition_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/initializer_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/skip_validations_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/allowlists/subrules_allowlist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/android/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/bash/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/bash/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/build_info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/build_info/templates/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/cc/whitelists/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/cc/whitelists/parse_headers_and_layering_check/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/cc/whitelists/starlark_hdrs_check/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_defs/repo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/build_rules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/buildstamp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/coverage/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/build_info_entry_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/build_info_entry_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/build_info_translation_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/build_info_translation_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/build_info_translation_helper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/modules_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/runfiles/runfiles.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/cpp/test_data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/def_parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/genrule/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/java/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/jdk/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/jdk/nosystemjdk/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/launcher/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/objc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/objc/dummy.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/osx/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/python/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/python/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/sh/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/java/com/google/devtools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/test/CoverageOutputGenerator/java/com/google/devtools/coverageoutputgenerator/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/whitelists/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/whitelists/config_feature_flag/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/whitelists/function_transition_whitelist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/windows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/zip/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/bazel_tools/tools/zip/zipper/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/conformance/proto2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/conformance/proto3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/conformance/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/doc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/doc/extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/expr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/expr/conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/expr/conformance/proto2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/expr/conformance/proto3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/expr/conformance/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/proto/cel/policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/tests/simple/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/cel-spec+/tests/simple/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/platforms/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/platforms/cpu/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/platforms/host/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/platforms/os/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.bazelci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.github/ISSUE_TEMPLATE/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.github/scripts/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/.github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/flags/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/flags/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/file_concat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/file_concat/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/oss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/oss/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/private/oss/toolchains/prebuilt/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/tests/proto_descriptor_set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/tests/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/bazel/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/benchmarks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/benchmarks/benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/build_defs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/binary_json_conformance_suite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/binary_json_conformance_suite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/binary_wireformat.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/binary_wireformat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/binary_wireformat_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/conformance_cpp.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/conformance_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/conformance_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/conformance_test_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/conformance_test_runner.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/failure_list_trie_node.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/failure_list_trie_node.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/failure_list_trie_node_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/fork_pipe_runner.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/fork_pipe_runner.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/naming.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/naming_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/test_manager.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/test_manager.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/test_manager_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/test_runner.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/testee.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/testee.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/testee_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/text_format_conformance_suite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/text_format_conformance_suite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/conformance/test_protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/csharp/protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/protos/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/Collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/Compatibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/Reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/TestProtos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/WellKnownTypes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/keys/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/AddressBook/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.JsonDump/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test.TestProtos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/Buffers/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/Collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/Compatibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/Reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf.Test/WellKnownTypes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/Collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/Compatibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/Compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/Properties/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/Reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/csharp/src/Google.Protobuf/WellKnownTypes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/design/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/design/editions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/design/editions/images/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/design/prototiller/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/docs/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/defaults_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/edition_defaults_test_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/edition_defaults_test_utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/edition_defaults_test_utils_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/generated_files_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/generated_reflection_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/internal_defaults_escape.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/codegen_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/golden/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/golden/edition2023_transform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/golden/edition2024_transform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/input/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/input/edition2023_transform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editions/input/edition2024_transform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/editors/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/add_person.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/list_people.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/example_without_cc_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/examples_with_hyphen/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/go/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/go/cmd/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/go/cmd/add_person/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/examples/go/cmd/list_people/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/go/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/go/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/go/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/hpb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/multibackend.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/requires.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/status.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/status.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/status_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/cpp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/cpp_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/error.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/interop.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/cpp/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/error.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/interop.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/interop_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/repeated_field_iterator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/repeated_field_iterator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/backend/upb/upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/message_lock.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/message_lock.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/message_lock_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/os_macros_restore.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/os_macros_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/template_help.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb/internal/template_help_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_accessors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_accessors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_enums.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_enums.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_extensions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_extensions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_messages.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_messages.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_repeated_fields.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_repeated_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/gen_utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/keywords.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/keywords.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/protoc-gen-hpb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/extension_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/multibackend_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/repeated_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/test_generated.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/hpb_generator/tests/test_hpb_bzl_alias.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/bom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/resources/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/main/resources/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/proto/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/proto/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/core/src/test/proto/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/main/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/main/kotlin/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/main/kotlin/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/main/kotlin/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/test/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/test/kotlin/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/test/kotlin/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin-lite/src/test/kotlin/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/main/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/main/kotlin/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/main/kotlin/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/main/kotlin/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/kotlin/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/kotlin/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/kotlin/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/proto/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/proto/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/kotlin/src/test/proto/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/test/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/test/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/test/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/lite/src/test/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/osgi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/protoc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/test/linkage-monitor-check-bom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/main/java/com/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/java/com/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/proto/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/proto/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/proto/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/java/util/src/test/proto/com/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/main.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/msg.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/lua/upbc.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBAny.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBApi.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBArray.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBArray_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBBootstrap.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBCodedInputStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBCodedInputStream_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBCodedOutputStream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBCodedOutputStream_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBDescriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBDescriptor_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBDictionary.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBDictionary_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBDuration.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBEmpty.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBExtensionInternals.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBExtensionRegistry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBFieldMask.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBMessage.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBMessage_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBProtocolBuffers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBProtocolBuffers_RuntimeSupport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBRootObject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBRootObject_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBRuntimeTypes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBSourceContext.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBStruct.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBTimestamp.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBType.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUnknownField.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUnknownField_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUnknownFields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUnknownFields_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUtilities.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBUtilities_PackagePrivate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBWellKnownTypes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBWireFormat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/GPBWrappers.pbobjc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/DevTools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_OSX.xcodeproj/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_OSX.xcodeproj/project.xcworkspace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_OSX.xcodeproj/project.xcworkspace/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_OSX.xcodeproj/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_OSX.xcodeproj/xcshareddata/xcschemes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_iOS.xcodeproj/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_iOS.xcodeproj/project.xcworkspace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_iOS.xcodeproj/project.xcworkspace/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_iOS.xcodeproj/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_iOS.xcodeproj/xcshareddata/xcschemes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_tvOS.xcodeproj/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_tvOS.xcodeproj/project.xcworkspace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_tvOS.xcodeproj/project.xcworkspace/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_tvOS.xcodeproj/xcshareddata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/ProtocolBuffers_tvOS.xcodeproj/xcshareddata/xcschemes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/Tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/Tests/GPBTestUtilities.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/objectivec/Tests/UnitTests-Bridging-Header.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/patches/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/patches/protobuf_v25/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/patches/protobuf_v29/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/arena.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/array.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/convert.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/convert.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/map.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/names.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/php-upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/php-upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/php_protobuf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/print_options.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/print_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/protobuf.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/protobuf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/wkt.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/ext/google/protobuf/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/GPBMetadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/GPBMetadata/Google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/GPBMetadata/Google/Protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/GPBMetadata/Google/Protobuf/Internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Field/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/DescriptorProto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/EnumDescriptorProto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/ExtensionRangeOptions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FeatureSet/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FeatureSet/VisibilityFeature/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FeatureSetDefaults/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FieldDescriptorProto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FieldOptions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/FileOptions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/GeneratedCodeInfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/GeneratedCodeInfo/Annotation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/MethodOptions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/SourceCodeInfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/src/Google/Protobuf/Internal/UninterpretedOption/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/generated_previous/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/generated_previous/GPBMetadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/generated_previous/GPBMetadata/ProtoPrevious/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/generated_previous/Previous/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/proto/empty/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/php/tests/proto_previous/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/pkg/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/pkg/test/test_lib.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/pkg/test/test_lib.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/convert.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/convert.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor_containers.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor_containers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor_pool.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/descriptor_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/extension_dict.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/extension_dict.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/map.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/protobuf.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/protobuf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/python_api.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/repeated.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/repeated.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/unknown_fields.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/unknown_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/dist/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/docs/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/docs/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/docs/google/protobuf/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/link_error_fast_cpp.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/link_error_pure_python.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/link_error_upb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/proto_api.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/proto_api.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/python_protobuf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/use_fast_cpp_protos.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/use_pure_python.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/use_upb_protos.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/api_implementation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/proto_api_test_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/pybind11_test_module.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/python_protobuf.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/import_test_package/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/internal/numpy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_containers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_containers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_database.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/descriptor_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/extension_dict.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/extension_dict.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/free_threading_mutex.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/map_container.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/map_container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/message_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/message_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/message_module.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/repeated_composite_container.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/repeated_composite_container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/repeated_scalar_container.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/repeated_scalar_container.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/safe_numerics.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/scoped_pyobject_ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/unknown_field_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/pyext/unknown_field_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/protobuf_distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/python/protobuf_distutils/protobuf_distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/convert.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/convert.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/defs.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/defs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/glue.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/map.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/protobuf.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/protobuf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/repeated_field.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/ruby-upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/ruby-upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/shared_convert.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/shared_convert.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/shared_message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/ext/google/protobuf_c/shared_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/protobuf/ffi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/protobuf/ffi/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/protobuf/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/google/tasks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/lib/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/com/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/com/google/protobuf/jruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/src/main/java/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/ruby/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/compare.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/compare.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/debug.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/debug.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/map.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/repeated.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/rust_alloc_for_cpp_api.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/serialized_data.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/cpp_kernel/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/protobuf_macros/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_codegen/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_codegen/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_example/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_example/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_example/proto/proto_example/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_example/proto/proto_example/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_example/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_macros/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_tests/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_tests/tests/protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_well_known_types/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/release_crates/protobuf_well_known_types/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/cpp/interop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/cpp/interop/test_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/encode_raw_string_as_crate_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/more_test_protos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/p/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/q/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/rust_proto_library_unit_test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/rust_proto_library_unit_test/empty.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/shared/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/shared/utf8/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/shared/utf8/utf8_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/test/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/upb_api.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/mem/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/message/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/mini_table/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/text/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/rust/upb/sys/wire/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/any_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/api.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/api.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_align.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_align.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_align_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_allocation_policy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_cleanup.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arena_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenastring.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenastring.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenastring_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenaz_sampler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenaz_sampler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/arenaz_sampler_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/cpp_edition_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/cpp_features.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/cpp_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/debug_counter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_database.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_database_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_legacy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_test_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_test_utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_visitor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/descriptor_visitor_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/drop_unknown_fields_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/duration.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/duration.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/dynamic_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/dynamic_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/dynamic_message_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/edition_message_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/empty.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/empty.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/explicitly_constructed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/extension_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/extension_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/extension_set_heavy.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/extension_set_inl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/extension_set_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/feature_resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/feature_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/feature_resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/field_access_listener.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/field_mask.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/field_mask.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/field_with_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/field_with_arena_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/fully_verify_message_sets_opt_out.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_enum_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_enum_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_enum_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_enum_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_bases.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_bases.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_reflection_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_decl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_full.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_gen.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_tctable_lite_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/generated_message_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/has_bits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/has_bits_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/implicit_weak_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/implicit_weak_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/inlined_string_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/inlined_string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/inlined_string_field_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_feature_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_feature_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_feature_helper_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_message_util_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_metadata_locator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_metadata_locator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_visibility.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/internal_visibility_for_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/lazily_build_dependencies_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/lite_arena_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/lite_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_field_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_probe_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_test.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/map_type_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_unittest.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/message_unittest_legacy_apis.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/metadata.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/metadata_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/micro_string.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/micro_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/micro_string_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/no_field_presence_map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/no_field_presence_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/os_macros_restore.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/os_macros_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/package_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/parse_context.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/parse_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/port.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/port_def.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/port_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/port_undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/preserve_unknown_enum_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/proto3_arena_lite_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/proto3_arena_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/proto3_lite_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/proto3_lite_unittest.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/raw_ptr.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/raw_ptr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/raw_ptr_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/redaction_metric_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_mode.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_mode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_mode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_ops.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_ops.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_ops_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_tester.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_tester.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_visit_field_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_visit_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/reflection_visit_fields_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_field_reflection_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_field_reflection_unittest.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_field_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_ptr_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_ptr_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/repeated_ptr_field_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/retention_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/runtime_version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/serial_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/service.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/source_context.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/source_context.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/string_block.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/string_block_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/string_member_robber.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/string_piece_field_support_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/string_view_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/struct.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/struct.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/symbol_checker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/symbol_checker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/symbol_checker_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_textproto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_util2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_util_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/test_util_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/text_format.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/text_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/text_format_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/thread_safe_arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/timestamp.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/timestamp.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/type.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/type.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unknown_field_set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unknown_field_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unknown_field_set_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unredacted_debug_format_for_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unredacted_debug_format_for_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/unredacted_debug_format_for_test_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/varint_shuffle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/varint_shuffle_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/well_known_types_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wire_format_unittest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wrappers.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/wrappers.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/bridge/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/annotation_test_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/annotation_test_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/code_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/code_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/code_generator_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/code_generator_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/code_generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/command_line_interface.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/command_line_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/command_line_interface_tester.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/command_line_interface_tester.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/command_line_interface_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/fake_plugin.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/importer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/importer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/importer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/main_no_generators.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/mock_code_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/mock_code_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/notices.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/package_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/parser_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/plugin.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/plugin.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/plugin.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/plugin.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/retention.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/retention.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/retention_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/scc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/subprocess.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/subprocess.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/test_plugin.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/versions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/versions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/versions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/zip_writer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/zip_writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/arena_ctor_visibility_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/bootstrap_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/copy_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/cpp_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_chunk.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_chunk.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_chunk_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/file_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/ifndef_guard.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/ifndef_guard.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/ifndef_guard_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message_layout_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message_layout_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/message_size_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/metadata_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/move_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/namespace_printer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/namespace_printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/namespace_printer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/padding_optimizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/parse_function_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/parse_function_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/plugin_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/service.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tracker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tracker.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/unittest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/unittest.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/cord_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/generators.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/string_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/field_generators/string_view_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tools/analyze_profile_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tools/analyze_profile_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tools/analyze_profile_proto_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/cpp/tools/analyze_profile_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_bootstrap_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_doc_comment.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_field_base.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_field_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_reflection_class.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_source_generator_base.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_source_generator_base.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/csharp/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/context.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/doc_comment.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/doc_comment.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/doc_comment_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/field_common.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/field_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/generator_common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/internal_helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/internal_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/java_features.pb.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/java_features.pb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/java_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/message_serialization.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/message_serialization.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/message_serialization_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/name_resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/name_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/name_resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/names_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/plugin_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/plugin_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/shared_code_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/shared_code_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/field_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/generator_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/make_field_gens.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/make_field_gens.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/service.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/service.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/string_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/full/string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/field_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/generator_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/generator_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/make_field_gens.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/make_field_gens.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/string_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/java/lite/string_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/annotation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/kotlin/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/enum_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/enum_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/extension.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/import_writer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/import_writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/line_consumer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/line_consumer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/line_consumer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/map_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/map_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/message_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/message_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/names_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/nsobject_methods.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/oneof.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/oneof.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/primitive_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/primitive_field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/text_format_decode_data_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/tf_decode_data.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/objectivec/tf_decode_data.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/php_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/php/php_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/plugin_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/plugin_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/pyi_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/pyi_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/python/python_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/release/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/rbs_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/rbs_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/rbs_generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/ruby_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/ruby_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/ruby/ruby_generator_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/context.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/crate_mapping.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/crate_mapping.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/crate_mapping_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/enum.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/enum_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/naming.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/naming.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/naming_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/oneof.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/oneof.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/relative_path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/relative_path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/relative_path_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/rust_field_type.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/rust_field_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/rust_keywords.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/rust_keywords.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/upb_helpers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/upb_helpers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/accessor_case.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/accessor_case.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/accessors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/accessors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/default_value.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/default_value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/map.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/repeated_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_cord.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_scalar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/singular_string.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/unsupported_field.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/with_presence.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/compiler/rust/accessors/with_presence.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/coded_stream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/coded_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/coded_stream_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/gzip_stream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/gzip_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/io_win32.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/io_win32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/io_win32_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/package_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/printer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/printer_death_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/printer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/strtod.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/strtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/test_zero_copy_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/test_zero_copy_stream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/tokenizer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/tokenizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/tokenizer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_sink.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_sink.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_sink_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream_impl_lite.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/io/zero_copy_stream_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/json.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/json.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/json_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/descriptor_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/lexer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/lexer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/lexer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/message_path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/message_path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/parser_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/unparser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/unparser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/unparser_traits.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/untyped_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/untyped_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/writer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/zero_copy_buffered_stream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/zero_copy_buffered_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/json/internal/zero_copy_buffered_stream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/callback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/common.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/common_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/platform_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/stubs/status_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testing/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testing/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testing/googletest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/testing/googletest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/delimited_message_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/delimited_message_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/delimited_message_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_comparator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_comparator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_comparator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_mask_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_mask_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/field_mask_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/internal_timeval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/json_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/message_differencer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/message_differencer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/message_differencer_unittest.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/package_info.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/time_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/time_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/time_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/type_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/type_resolver_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/type_resolver_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/type_resolver_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/python/field_mask_util_clif_aux.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/python/field_mask_util_clif_aux.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/google/protobuf/util/python/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/src/solaris/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/ascii.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/boost.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/lemire-avx2.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/lemire-neon.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/lemire-sse.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/lookup.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/main.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/naive.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/range-avx2.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/range-neon.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/range-sse.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/range2-neon.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/range2-sse.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_range.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_range_neon.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_range_sse.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_validity.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_validity_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/fuzz/utf8_validity_fuzzer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_corpus_dir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_to_utf16/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_to_utf16/iconv.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_to_utf16/main.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/third_party/utf8_range/utf8_to_utf16/naive.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/generated_code_support.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/descriptor_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/error_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/status.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/status.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/status.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/string_view.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/string_view_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/upcast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/internal/endian.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/base/internal/log2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/bazel/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/bazel/private/oss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/bazel/private/upb_proto_library_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/conformance/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/conformance/conformance_upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/common.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/int_table.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/str_table.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/hash/test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/chunked_input_stream.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/chunked_input_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/chunked_output_stream.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/chunked_output_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/string_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/tokenizer.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/tokenizer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/tokenizer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/zero_copy_input_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/zero_copy_output_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/io/zero_copy_stream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/decode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/decode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/decode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/encode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/encode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/encode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/json/fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/atoi.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/atoi.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/atoi_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/round_trip.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/round_trip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/round_trip_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/strtod.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/strtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/unicode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/lex/unicode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/alloc.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/alloc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/arena.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/arena.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/arena_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mem/internal/arena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/accessors.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/accessors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/accessors.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/accessors_split64.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/accessors_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/array.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/array_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/compare.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/compare.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/compat.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/compat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/copy.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/copy.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/copy_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/map.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/map_gencode_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/map_sorter.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/map_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/merge.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/merge.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/merge_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/promote.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/promote.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/promote_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/utf8_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/value.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/accessors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/compare_unknown.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/compare_unknown.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/compare_unknown_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/extension.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/iterator.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/iterator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/map.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/map_entry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/map_sorter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/message/internal/types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/build_enum.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/build_enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/decode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/decode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/link.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/link.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/base92.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/base92.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/decoder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/encode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/encode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/encode.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/encode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/modifiers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_descriptor/internal/wire_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/compat.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/compat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/compat_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/debug_string.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/debug_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/debug_string_test_generate.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/extension_registry.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/extension_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/generated_registry.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/generated_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/generated_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/message_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/sub.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/enum.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/extension.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/field.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/generated_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/size_log2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/mini_table/internal/sub.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/atomic.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/def.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/sanitizers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/undef.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/port/vsnprintf_compat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def_pool.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def_type.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/def_type.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/desc_state.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/descriptor_bootstrap.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_reserved_range.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_reserved_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_value_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/enum_value_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/extension_range.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/extension_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/field_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/field_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/file_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/file_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message.hpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message_reserved_range.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/message_reserved_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/method_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/method_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/oneof_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/oneof_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/reflection_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/service_def.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/service_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/google/protobuf/descriptor.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/google/protobuf/descriptor.upb_minitable.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/cmake/google/protobuf/descriptor.upb_minitable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/def_builder.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/def_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/def_builder_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/def_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/desc_state.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/enum_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/enum_reserved_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/enum_value_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/extension_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/field_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/file_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/message_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/message_reserved_range.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/method_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/oneof_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/service_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/strdup2.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/strdup2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/internal/upb_edition_defaults.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/stage0/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/stage0/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/stage0/google/protobuf/descriptor.upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/reflection/stage0/google/protobuf/descriptor.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/editions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/fuzz_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/fuzz_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/length_prefixed_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/parse_text_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/proto3_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/test_cpp.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/test_generated_code.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/test_import_empty_srcs.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/test/test_mini_table_oneof.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/debug_string.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/debug_string.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/encode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/encode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/encode_debug_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/internal/encode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/text/internal/encode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/def_to_proto.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/def_to_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/def_to_proto_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/def_to_proto_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/def_to_proto_test.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/required_fields.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/required_fields.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/util/required_fields_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/byte_size.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/byte_size.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/byte_size_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/encode.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/encode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/eps_copy_input_stream.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/eps_copy_input_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/eps_copy_input_stream_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/reader.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/reader.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/writer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/bisect_helper.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/cardinality.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/cardinality.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/combinations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/data.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/dispatch.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/dispatch.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/field_fixed.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/field_message.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/field_parsers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/field_string.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/field_varint.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/function_array.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/function_array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/select.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/select.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/decode_fast/select_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/decoder.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/decoder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/eps_copy_input_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/internal/reader.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/field_types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/make_mini_table.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/make_mini_table.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/wire_message.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb/wire/test_util/wire_message.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/file_layout.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/file_layout.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/plugin.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/plugin.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/plugin_bootstrap.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/names_internal.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/c/names_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/protobuf/compiler/plugin.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/protobuf/compiler/plugin.upb_minitable.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/cmake/google/protobuf/compiler/plugin.upb_minitable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common/cpp_to_upb_def.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common/cpp_to_upb_def.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/common/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/names_internal.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/minitable/names_internal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/header.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/header.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/source.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/reflection/source.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/google/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/google/protobuf/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/google/protobuf/compiler/plugin.upb.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/protobuf+/upb_generator/stage0/google/protobuf/compiler/plugin.upb.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/testinstall.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/.bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/.github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/app/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/app/_re2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/benchlog/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/doc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/lib/git/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/python/_re2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/python/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/bitmap256.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/bitmap256.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/bitstate.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/compile.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/dfa.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/filtered_re2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/filtered_re2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/mimics_pcre.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/nfa.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/onepass.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/parse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/perl_groups.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/pod_array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prefilter.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prefilter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prefilter_tree.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prefilter_tree.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prog.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/prog.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/re2.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/re2.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/regexp.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/regexp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/set.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/simplify.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/sparse_array.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/sparse_set.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/stringpiece.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/tostring.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/unicode_casefold.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/unicode_casefold.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/unicode_groups.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/unicode_groups.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/walker-inl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/fuzzing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/fuzzing/re2_fuzzer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/backtrack.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/charclass_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/compile_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/dfa_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/dump.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive1_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive2_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive3_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive_tester.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/exhaustive_tester.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/filtered_re2_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/mimics_pcre_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/null_walker.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/parse_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/possible_match_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/random_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/re2_arg_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/re2_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/regexp_benchmark.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/regexp_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/regexp_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/regexp_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/required_prefix_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/search_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/set_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/simplify_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/string_generator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/string_generator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/string_generator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/tester.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/re2/testing/tester.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/malloc_counter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/pcre.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/pcre.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/rune.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/strutil.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/strutil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/re2+/util/utf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc++cc_configure_extension+local_config_cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc++cc_configure_extension+local_config_cc/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc++cc_configure_extension+local_config_cc/tools/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc++cc_configure_extension+local_config_cc/tools/cpp/empty.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/.bazelci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/.bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/.github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/bazel7/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/compile/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/link/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/rules_impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/rules_impl/fdo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/toolchain/empty.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/toolchain/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/private/toolchain_config/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/runfiles/runfiles.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/runfiles/runfiles.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/actions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/archiver_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/compile_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/compiler_input_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/compiler_output_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/dependency_file/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/external_include_paths/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/fission_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/generate_linkmap/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/include_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/libraries_to_link/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/libraries_to_link/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/library_search_directories/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/link_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/linker_param_file/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/linkstamp_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/objc_arc_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/pic_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/preprocessor_defines/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/random_seed/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/runtime_library_search_directories/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/shared_flag/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/soname_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/static_libgcc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/strip_debug_symbols/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/args/strip_flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/artifacts/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/capabilities/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/features/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/features/legacy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/cc/toolchains/variables/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/custom_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/custom_toolchain/buildme.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_archive/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_archive/bar.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_archive/foo.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_archive/main.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_compile/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/my_c_compile/foo.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/quick_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/asm_answer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/asm_answer/public/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/asm_answer/public/asm_answer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/constraint/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/dynamic_answer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/dynamic_answer/dynamic_answer.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/dynamic_answer/public/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/dynamic_answer/public/dynamic_answer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/static_answer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/static_answer/static_answer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/static_answer/public/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/static_answer/public/static_answer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/clang/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/clang/args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/clang/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/gcc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/gcc/args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/rule_based_toolchain/toolchains/gcc/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/examples/write_cc_toolchain_cpu/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/compiler_settings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/compiler_settings/main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/load_from_macro/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/load_from_macro/foo.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/actions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/args_list/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/features/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/legacy_features_as_args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/legacy_features_as_args/goldens/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/legacy_features_as_args/goldens/macos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/legacy_features_as_args/goldens/unix/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/nested_args/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/testdata/subdir1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/testdata/subdir2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/testdata/subdir3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/tool/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/tool_map/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/toolchain_config/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/rule_based_toolchain/variables/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/runfiles/runfiles_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_binary/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_binary/bar.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_binary/foo.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_import/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_import/foo.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/simple_import/foo.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_cc+/tests/system_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing++non_module_dependencies+rules_fuzzing_oss_fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/.bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/.github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/empty_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/fuzzed_data_provider_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/hang_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/input_buffer_overflow_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/msan_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/new_buffer_overflow_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/oom_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/re2_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/runfiles_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/ubsan_function_ptr_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/ubsan_int_overflow_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/bzlmod/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/bzlmod/cc_fuzz_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/corpus_dir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/corpus_dir/secondary_dir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/dictionaries/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeFuzzTest.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeFuzzTest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeRunfileFuzzTest.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeRunfileFuzzTest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeUbsanFuncPtrFuzzTest.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/java/com/example/NativeUbsanFuncPtrFuzzTest.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/examples/test_corpus_dir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/engines/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/private/oss_fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/private/runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/file_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/file_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/file_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/replay_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/status_util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/status_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/status_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_file_buffer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_file_buffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_file_buffer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_replayer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_replayer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/replay/test_replayer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_fuzzing+/fuzzing/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/classfile.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/common.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/dummy_zlib_client.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/ijar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/mapped_file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/mapped_file_unix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/mapped_file_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/platform_utils.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/platform_utils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/zip.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/zip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/zip_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/zlib_client.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/ijar/zlib_client.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/bazel_log_handler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/bazel_log_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/errors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/errors_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/errors_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/exit_code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/file_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/file_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/file_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/logging.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/logging.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/md5.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/md5.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/numbers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/numbers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/path_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/path_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/path_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/port.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/cpp/util/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/windows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/windows/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/windows/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/windows/util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/native/windows/util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/main/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/combiners.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/combiners.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/diag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/input_jar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/input_jar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/log4j2_plugin_dat_combiner.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/log4j2_plugin_dat_combiner.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/mapped_file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/mapped_file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/mapped_file_posix.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/mapped_file_windows.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/options.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/output_jar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/output_jar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/singlejar_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/token_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/transient_bytes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/zip_headers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/java_tools/src/tools/singlejar/zlib_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/bazel_log_handler.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/bazel_log_handler.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/errors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/errors_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/errors_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/exit_code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/file_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/file_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/file_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/logging.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/logging.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/md5.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/md5.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/numbers.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/numbers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/path.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/path.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/path_platform.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/path_posix.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/path_windows.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/port.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/cpp/util/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/windows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/windows/file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/windows/file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/windows/util.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/native/windows/util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/main/protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/allowlist.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/allowlist.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/duplicate_class_collector.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/duplicate_class_collector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/one_version.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/one_version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/one_version/one_version_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/combiners.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/combiners.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/diag.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/input_jar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/input_jar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/log4j2_plugin_dat_combiner.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/log4j2_plugin_dat_combiner.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/mapped_file.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/mapped_file.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/mapped_file_posix.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/mapped_file_windows.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/options.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/output_jar.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/output_jar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/port.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/singlejar_main.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/token_stream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/transient_bytes.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/zip_headers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/src/tools/singlejar/zlib_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/third_party/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/third_party/java/jacoco/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools/java_tools/third_party/java/proguard/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/ijar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/src/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/src/tools/one_version/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remote_java_tools_linux/java_tools/src/tools/singlejar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/security/policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/security/policy/limited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/conf/security/policy/unlimited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/CodePointIM/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/FileChooserDemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/Font2DTest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/J2Ddemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/Metalworks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/Notepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/SampleTree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/Stylepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/SwingSet2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/TableExample/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/jfc/TransparentRuler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/FileChooserDemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/FileChooserDemo/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Font2DTest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Font2DTest/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Metalworks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Metalworks/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Notepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/Notepad/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/SampleTree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/SampleTree/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/SwingApplet/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/SwingApplet/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/TableExample/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/TableExample/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/TransparentRuler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/jfc/TransparentRuler/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/FullThreadDump/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/FullThreadDump/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/JTop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/JTop/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/MemoryMonitor/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/MemoryMonitor/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/VerboseGC/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/management/VerboseGC/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/scripting/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/scripting/jconsole-plugin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/demo/nbproject/scripting/jconsole-plugin/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/classfile_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/jawt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/jdwpTransport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/jni.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/jvmti.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/jvmticmlr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/linux/jawt_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/include/linux/jni_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/jmods/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/com.azul.crs.client/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/com.azul.tooling/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.datatransfer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.desktop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.instrument/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.management.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.naming/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.net.http/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.prefs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.scripting/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.se/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.security.jgss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.security.sasl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.smartcardio/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.sql.rowset/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.sql/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.transaction.xa/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.xml.crypto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/java.xml/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.accessibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.aot/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.attach/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.charsets/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.crypto.cryptoki/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.crypto.ec/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.dynalink/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.editpad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.hotspot.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.httpserver/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.ed/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.jvmstat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.le/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.opt/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.vm.ci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.vm.compiler.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.internal.vm.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jartool/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.javadoc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jcmd/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jconsole/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jdeps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jdi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jdwp.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jlink/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jshell/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jsobject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.jstatd/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.localedata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.management.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.management.jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.naming.dns/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.naming.ldap/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.naming.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.net/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.pack/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.rmic/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.scripting.nashorn.shell/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.scripting.nashorn/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.sctp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.security.auth/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.security.jgss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.unsupported.desktop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.unsupported/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.xml.dom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/legal/jdk.zipfs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/lib/jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/lib/jli/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/lib/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/lib/server/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/ja/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/ja/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/ja_JP.UTF-8/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/ja_JP.UTF-8/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk11_linux/man/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/sdp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/security/policy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/security/policy/limited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/conf/security/policy/unlimited/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/CodePointIM/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/FileChooserDemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/Font2DTest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/J2Ddemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/Metalworks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/Notepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/SampleTree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/Stylepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/SwingSet2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/TableExample/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/jfc/TransparentRuler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/FileChooserDemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/FileChooserDemo/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Font2DTest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Font2DTest/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Metalworks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Metalworks/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Notepad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/Notepad/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/SampleTree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/SampleTree/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/TableExample/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/TableExample/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/TransparentRuler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/demo/nbproject/jfc/TransparentRuler/nbproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/classfile_constants.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/jawt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/jdwpTransport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/jni.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/jvmti.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/jvmticmlr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/linux/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/linux/jawt_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/include/linux/jni_md.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/jmods/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/com.azul.crs.client/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/com.azul.tooling/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.base/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.datatransfer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.desktop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.instrument/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.management.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.naming/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.net.http/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.prefs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.scripting/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.se/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.security.jgss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.security.sasl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.smartcardio/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.sql.rowset/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.sql/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.transaction.xa/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.xml.crypto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/java.xml/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.accessibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.attach/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.charsets/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.crypto.cryptoki/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.crypto.ec/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.dynalink/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.editpad/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.hotspot.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.httpserver/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.incubator.vector/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.ed/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.jvmstat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.le/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.opt/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.vm.ci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.vm.compiler.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.internal.vm.compiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jartool/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.javadoc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jcmd/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jconsole/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jdeps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jdi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jdwp.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jlink/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jpackage/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jshell/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jsobject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.jstatd/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.localedata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.management.agent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.management.jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.management/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.naming.dns/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.naming.rmi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.net/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.nio.mapmode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.random/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.sctp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.security.auth/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.security.jgss/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.unsupported.desktop/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.unsupported/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.xml.dom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/legal/jdk.zipfs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/lib/jfr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/lib/security/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/lib/server/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/man/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java++toolchains+remotejdk21_linux/man/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/bazel/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/bazel/rules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/common/rules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/common/rules/impl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/com/google/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/com/google/devtools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/com/google/devtools/build/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/runfiles/src/main/java/com/google/devtools/build/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/java/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_java+/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/licenses/generic/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/licenses/spdx/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/rules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/rules/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/rules_gathering/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/sample_reports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_license+/tools/sbom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps/_config/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps/absl_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps/six/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/flags/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl/testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++pip+rules_fuzzing_py_deps_311_absl_py/site-packages/absl_py-2.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/Python.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bltinmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/boolobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bytearrayobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/codecs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/complexobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/datetime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/descrobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/dictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/dynamic_annotations.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/enumobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/errcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/exports.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/fileobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/frameobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/genericaliasobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/intrcheck.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/iterobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/listobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/longobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/marshal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/memoryobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/methodobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/modsupport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/moduleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/objimpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/opcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/osdefs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/osmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/patchlevel.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/py_curses.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pybuffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pycapsule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pydtrace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyexpat.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyframe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymacconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymacro.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pyport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystrcmp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pystrtod.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pythonrun.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pythread.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/pytypedefs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/rangeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/setobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/sliceobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/structmember.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/structseq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/token.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/tracemalloc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/tupleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/typeslots.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/weakrefobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/bytearrayobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/cellobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/classobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/complexobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/descrobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/dictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/fileobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/frameobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/funcobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/genobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/initconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/listobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/longintrepr.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/longobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/methodobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/modsupport.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/objimpl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/odictobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/picklebufobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pthread_stubs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyctype.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pydebug.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyfpe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pyframe.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pythonrun.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pythread.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/pytime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/setobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/tupleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/cpython/weakrefobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_abstract.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_accu.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_asdl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ast_state.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_atomic.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_atomic_funcs.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bitutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_blocks_output_buffer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bytes_methods.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_bytesobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_call.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ceval.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_code.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_compile.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_condvar.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_dict.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_dtoa.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_emscripten_signal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_exceptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_fileutils.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_floatobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_format.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_frame.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_gc.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_genobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_getopt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_gil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_global_objects.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_global_strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_hamt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_hashtable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_import.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_initconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_interp.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_interpreteridobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_list.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_long.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_moduleobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_namespace.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_object.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_opcode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pathconfig.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyarena.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyerrors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pyhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pylifecycle.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pymath.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pymem.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_pystate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_runtime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_runtime_init.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_signal.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_sliceobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_strhex.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_structseq.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_symtable.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_sysmodule.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_traceback.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_tuple.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_typeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_ucnhash.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_unicodeobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_unionobject.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/include/python3.11/internal/pycore_warnings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/itcl4.2.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/pkgconfig/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/__phello__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/asyncio/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/asyncio/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/collections/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/futures/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/concurrent/futures/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/config-3.11-x86_64-linux-gnu/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/config-3.11-x86_64-linux-gnu/config.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ctypes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ctypes/macholib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/curses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/dbm/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/distutils/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/email/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/email/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/email/mime/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/encodings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/encodings/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ensurepip/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/ensurepip/_bundled/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/html/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/html/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/http/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/http/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/idlelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/idlelib/Icons/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/metadata/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/importlib/resources/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/json/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/json/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib-dynload/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/fixes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/lib2to3/pgen2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/logging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/logging/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/multiprocessing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/multiprocessing/dummy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/pydoc_data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/re/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/re/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/_distutils_hack/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/_distutils_hack/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip-24.3.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/cli/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/commands/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/distributions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/index/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/locations/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/metadata/importlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/models/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/network/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/build/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/operations/install/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/req/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/legacy/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/utils/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_internal/vcs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/cachecontrol/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/cachecontrol/caches/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/certifi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/distlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/distro/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/idna/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/msgpack/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pkg_resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/platformdirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/filters/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/lexers/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pygments/styles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pyproject_hooks/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/pyproject_hooks/_in_process/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/requests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/resolvelib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/resolvelib/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/rich/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/tomli/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/truststore/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/contrib/_securetransport/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/packages/backports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pip/_vendor/urllib3/util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package-source/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package-zip/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools-80.9.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools-80.9.0.dist-info/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compilers/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compilers/C/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/compilers/C/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_distutils/tests/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/autocommand/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/tarfile/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/backports/tarfile/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/inflect/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/collections/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/functools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/jaraco/text/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/more_itertools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging-24.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/packaging/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/platformdirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/tomli/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typeguard/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel-0.45.1.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/cli/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/vendored/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/wheel/vendored/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/_vendor/zipp/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/command/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/config/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/compat/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/config/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/config/downloads/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/indexes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/indexes/test_links_priority/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/indexes/test_links_priority/simple/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/site-packages/setuptools/tests/integration/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/sqlite3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/tkinter/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/tomllib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/turtledemo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/unittest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/urllib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/urllib/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/venv/scripts/posix/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/wsgiref/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/dom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/dom/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/etree/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/parsers/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/parsers/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xml/sax/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xmlrpc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/xmlrpc/__pycache__/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/python3.11/zoneinfo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/tclAppInit.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/encoding/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/http1.0/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/msgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8.6/opt0.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.4/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.4/platform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.5/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tcl8/8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/thread2.8.9/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/tkAppInit.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/demos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/demos/images/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/images/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/msgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/lib/tk8.6/ttk/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/man/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python++python+python_3_11_x86_64-unknown-linux-gnu/share/man/man1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.bazelci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.bcr/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.bcr/gazelle/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.ci/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.github/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.github/ISSUE_TEMPLATE/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/.github/workflows/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/_includes/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/_static/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/_static/css/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/python/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/python/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/python/config_settings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/python/runtime_env_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/api/rules_python/tools/precompiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/howto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/docs/pypi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/build_file_generation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/build_file_generation/random_number_generator/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/entry_points/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/entry_points/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/libs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/libs/my_lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/other_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/other_module/other_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/other_module/other_module/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/other_module/other_module/pkg/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/patches/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/example.com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/example.com/another_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/example.com/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/foo_external/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/foo_external/nested/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/py_proto_library/foo_external/nested/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/runfiles/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/tests/other_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/whl_mods/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod/whl_mods/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/other_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/other_module/other_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/other_module/other_module/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/other_module/other_module/pkg/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/bzlmod_build_file_generation/runfiles/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/multi_python_versions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/multi_python_versions/libs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/multi_python_versions/libs/my_lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/multi_python_versions/requirements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/multi_python_versions/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/pip_parse/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/pip_parse_vendored/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/pip_repository_annotations/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/pip_repository_annotations/data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/py_proto_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/py_proto_library/example.com/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/py_proto_library/example.com/another_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/py_proto_library/example.com/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/wheel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/wheel/lib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/examples/wheel/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/manifest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/manifest/generate/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/manifest/hasher/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/manifest/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/manifest/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/modules_mapping/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/add_type_stub_packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/annotation_include_dep/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/annotation_include_dep/subpkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/annotation_include_pytest_conftest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/annotation_include_pytest_conftest/with_conftest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/annotation_include_pytest_conftest/without_conftest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/binary_without_entrypoint/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/binary_without_entrypoint_per_file_generation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/binary_without_entrypoint_per_file_generation_partial_update/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/clear_out_deps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/clear_out_deps/a/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/clear_out_deps/b/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/clear_out_deps/c/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/somewhere/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/somewhere/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dependency_resolution_order/third_party/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/different_packages_in_same_namespace/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test1_default/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test2_default_with_python_root/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test3_injection/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test4_multiple_labels/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test5_none_label/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test6_default_label/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test6_default_label/subpkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test7_none_label_with_extra_vis/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj1/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj1/src/pkg1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj2/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test8_multiple_python_root_dirs/proj2/src/pkg2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test9_default_vis_with_python_vis/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test9_default_vis_with_python_vis/subpkg1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_default_visibility/test9_default_vis_with_python_vis/subpkg2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test1_default_with_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test2_default_without_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test3_disabled_with_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test4_disabled_without_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test5_enabled_with_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test6_enabled_without_proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test7_removes_when_unnecessary/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto/test8_disabled_ignores_py_proto_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto_bzlmod_protobuf/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_generate_proto_bzlmod_protobuf_renamed/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_convention/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_convention/test1_unset/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_convention/test2_custom_prefix_colon/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_normalization/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_normalization/test1_type_none/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_normalization/test2_type_pep503/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_normalization/test3_type_snake_case/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_label_normalization/test4_unset_defaults_to_snake_case/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_proto_naming_convention/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_proto_naming_convention/test1_python_generation_disabled_does_nothing/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_proto_naming_convention/test2_python_generation_enabled_uses_default/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_proto_naming_convention/test3_python_generation_enabled_uses_value/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_proto_naming_convention/test4_python_generation_enabled_with_preexisting_keeps_intact/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test1_unset/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test2_star_test_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test3_test_star_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test4_glob/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test5_multiple_patterns/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test6_nesting/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern/test6_nesting/subpkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern_bad_glob/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_test_file_pattern_no_value/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_visibility/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_visibility/subdir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_visibility/subdir_python_root/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/directive_python_visibility/subdir_python_root/subdir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/disable_import_statements_validation/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dont_ignore_setup/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/dont_rename_target/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/file_name_matches_import_statement/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/one/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/one/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/one/bar/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/one/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/three/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_dependencies/two/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/one/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/undiscoverable/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/undiscoverable/package1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/first_party_file_and_directory_modules/undiscoverable/package1/subpackage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/foo/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_from_init_py/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_from_multiple/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_nested_file/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_nested_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_nested_var/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/import_top_level_var/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/from_imports/std_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/generated_test_entrypoint/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/ignored_invalid_imported_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/invalid_annotation_exclude/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/invalid_annotation_include_dep/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/invalid_imported_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/invalid_imported_module/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/a/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/_boundary/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/bar/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/coarse_grained/foo/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/one/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/one/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/one/bar/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/one/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/three/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/two/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/wont_generate/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/wont_generate/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/wont_generate/bar/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/monorepo/wont_generate/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/multiple_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention/dont_rename/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention/resolve_conflict/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention_binary_fail/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention_library_fail/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/naming_convention_test_fail/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file_non_empty_init/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file_subdirs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file_subdirs/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file_subdirs/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_file_subdirs/test_target/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/per_package_test_target_without_entry_point/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode_with_test_entrypoint/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode_with_test_entrypoint/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode_with_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/project_generation_mode_with_tests/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/py312_syntax/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/python_ignore_dependencies_directive/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/python_ignore_files_directive/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/python_ignore_files_directive/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/python_ignore_files_directive/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/python_target_with_test_in_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/my_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/my_library/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/subpackage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/subpackage1/subpackage2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package1/subpackage1/subpackage2/library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_package_mode/package2/library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_project_mode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_project_mode/package1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_project_mode/package2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/relative_imports_project_mode/package2/subpackage1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/remove_invalid_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/remove_invalid_library/others/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/respect_kind_mapping/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports_disabled/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports_disabled/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports_disabled_file_mode/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/sibling_imports_disabled_file_mode/pkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_binary/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_binary_with_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_library_without_init/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_library_without_init/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_test_with_conftest/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_test_with_conftest/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_test_with_conftest_sibling_imports_disabled/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/simple_test_with_conftest_sibling_imports_disabled/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/bar/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/baz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_build/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_build/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_build_bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_build_bazel/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_init/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_init/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_main/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_main/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/foo/has_test/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/one/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/subdir_sources/one/two/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_across_packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_across_packages/a/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_across_packages/b/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_disabled/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_package/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/type_checking_imports_project/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/with_nested_import_statements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/with_std_requirements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/with_third_party_requirements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/python/testdata/with_third_party_requirements_from_imports/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/gazelle/pythonconfig/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/api/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/bin/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/config_settings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/config_settings/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/constraints/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/entry_points/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/extensions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/local_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/pip_install/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/api/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/pypi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/pypi/dependency_resolver/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/pypi/requirements_parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/pypi/whl_installer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/private/whl_filegroup/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/proto/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/runtime_env_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/uv/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/python/uv/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/docs/api/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/docs/api/sphinxdocs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/docs/api/sphinxdocs/inventories/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/inventories/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/src/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/src/sphinx_bzl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/tests/proto_to_markdown/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/tests/sphinx_docs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/sphinxdocs/tests/sphinx_stardoc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/api/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/api/py_common/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/precompile/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/py_binary/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/py_info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/py_library/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/base_rules/py_test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/bootstrap_impls/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/bootstrap_impls/a/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/bootstrap_impls/a/b/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/bootstrap_impls/a/b/c/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/builders/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/cc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/cc/current_py_cc_headers/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/cc/current_py_cc_libs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/cc/current_py_cc_libs/python_libs_linking_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/cc/py_cc_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/config_settings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/config_settings/transition/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/deprecated/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/entry_points/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/envsubst/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/exec_toolchain_matching/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub1/ns-sub1-1.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub1/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub1/nspkg/subpkg1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub2/ns_sub2-1.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub2/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/implicit_namespace_packages/testdata/ns-sub2/nspkg/subpkg2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/compile_pip_requirements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/compile_pip_requirements_test_from_external_repo/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/custom_commands/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/ignore_root_user_error/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/ignore_root_user_error/submodule/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/local_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/local_toolchains/echo_ext.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/pip_parse/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/pip_parse/empty/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/integration/py_cc_toolchain_registered/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/interpreter/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/load_from_macro/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/another_module/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_delta/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_delta/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_delta/site-packages/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_delta/site-packages/nspkg/subnspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_delta/site-packages/nspkg/subnspkg/delta/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_gamma/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_gamma/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_gamma/site-packages/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_gamma/site-packages/nspkg/subnspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_gamma/site-packages/nspkg/subnspkg/gamma/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_single/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/nspkg_single/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v1/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v1/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v1/site-packages/simple-1.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v1/site-packages/simple/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v1/site-packages/simple_v1_extras/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/site-packages/simple-2.0.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/site-packages/simple-2.0.0.dist-info/licenses/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/site-packages/simple.libs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/simple_v2/site-packages/simple/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/with_external_data/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/modules/other/with_external_data/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/multiple_inputs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/multiple_inputs/a/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/multiple_inputs/b/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/no_unsafe_paths/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/normalize_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/packaging/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_exec_tools_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_runtime_info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_runtime_pair/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_wheel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/py_wheel/py_wheel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/config_settings/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/env_marker_setting/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/extension/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/generate_group_library_build_bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/generate_whl_library_build_bazel/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/index_sources/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/integration/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/namespace_pkgs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/parse_requirements/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/parse_requirements_txt/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/parse_simpleapi_html/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/parse_whl_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/patch_whl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/pep508/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/pkg_aliases/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/python_tag/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/render_pkg_aliases/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/requirements_files_by_platform/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/select_whl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/simpleapi_download/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/whl_installer/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/whl_library_targets/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/whl_metadata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/whl_repo_name/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/pypi/whl_target_platforms/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/repl/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/repl/helper/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/runfiles/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/runtime_env_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/support/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/support/cc_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/support/empty_toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/support/py_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/support/whl_from_dir/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/text_util/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/toolchains/transitions/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/lock/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/lock/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/toolchain/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/uv/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/uv/uv_toolchains/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_alpha/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_alpha/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_alpha/site-packages/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_alpha/site-packages/nspkg/subnspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_alpha/site-packages/nspkg/subnspkg/alpha/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_beta/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_beta/site-packages/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_beta/site-packages/nspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_beta/site-packages/nspkg/subnspkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/venv_site_packages_libs/nspkg_beta/site-packages/nspkg/subnspkg/beta/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/version/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/version_label/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_filegroup/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_filegroup/whl_headers_test.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_with_build_files/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_with_build_files/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_with_build_files/testdata/somepkg-1.0.dist-info/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_with_build_files/testdata/somepkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tests/whl_with_build_files/testdata/somepkg/subpkg/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/build_defs/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/build_defs/python/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/build_defs/python/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/launcher/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/precompiler/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/private/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/private/update_deps/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/rules_python+/tools/publish/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/adler32.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/compress.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/crc32.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/crc32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/deflate.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/deflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/gzclose.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/gzguts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/gzlib.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/gzread.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/gzwrite.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/infback.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inffast.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inffast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inffixed.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inflate.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inflate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inftrees.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/inftrees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/trees.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/trees.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/uncompr.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/zconf.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/zlib.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/zutil.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/zutil.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/amiga/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/ada/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/blast/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/blast/blast.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/blast/blast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/delphi/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/dotzlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/dotzlib/DotZLib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/gcc_gvmat64/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/infback9.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/infback9.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/inffix9.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/inflate9.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/inftree9.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/infback9/inftree9.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream/test.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream/zfstream.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream/zfstream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream2/zstream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream2/zstream_test.cpp
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream3/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream3/test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream3/zfstream.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/iostream3/zfstream.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/crypt.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/ioapi.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/ioapi.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/iowin32.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/iowin32.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/miniunz.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/minizip.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/mztools.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/mztools.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/unzip.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/unzip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/zip.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/minizip/zip.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/nuget/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/pascal/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/puff/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/puff/puff.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/puff/puff.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/puff/pufftest.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/testzlib/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/testzlib/testzlib.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/untgz/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/untgz/untgz.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc10/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc11/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc12/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc14/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc17/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/contrib/vstudio/vc9/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/doc/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/enough.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/fitblk.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gun.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gzappend.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gzjoin.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gzlog.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gzlog.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/gznorm.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/zpipe.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/zran.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/examples/zran.h
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/msdos/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/nintendods/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/old/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/old/os2/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/os400/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/os400/zlib.inc
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/qnx/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/test/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/test/example.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/test/infcover.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/test/minigzip.c
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/watcom/
Step #3 - "compile-libfuzzer-coverage-x86_64": external/zlib+/win32/
Step #3 - "compile-libfuzzer-coverage-x86_64": fuzz/
Step #3 - "compile-libfuzzer-coverage-x86_64": fuzz/fuzz_eval.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": fuzz/fuzz_parse.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/align.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/align_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/benchmark.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/casts.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/empty_descriptors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/empty_descriptors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/empty_descriptors_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/equals_text_proto.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/equals_text_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/exceptions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/json.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/json.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/json_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/lexis.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/lexis.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/lexis_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/manual.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/message_equality.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/message_equality.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/message_equality_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/message_type_name.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/message_type_name_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/minimal_descriptor_database.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/minimal_descriptor_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/minimal_descriptors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/names.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/names.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/names_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/new.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/new.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/new_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/noop_delete.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/number.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/number_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/overflow.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/overflow.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/overflow_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/parse_text_proto.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_file_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_matchers.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_time_encoding.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_time_encoding.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_time_encoding_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/proto_util_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/protobuf_runtime_version.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/re2_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/runfiles.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/runfiles.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/status_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/status_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/string_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/string_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/string_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/strings.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/strings.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/strings_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing_descriptor_pool.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing_descriptor_pool.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing_descriptor_pool_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing_message_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/testing_message_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/time.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/time.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/time_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/to_address.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/to_address_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/unicode.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/utf8.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/utf8.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/utf8_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/well_known_types.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/well_known_types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": internal/well_known_types_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_expr_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_expr_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_expr_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/macro_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser_benchmarks.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser_subset_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser_subset_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/parser_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/source_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/standard_macros.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/standard_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/standard_macros_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": parser/internal/options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/activation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/activation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/activation_interface.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/activation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/comprehension_vulnerability_check.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/comprehension_vulnerability_check.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/comprehension_vulnerability_check_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/constant_folding.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/constant_folding.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/constant_folding_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/embedder_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/embedder_context_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_adapter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_overload_reference.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/function_registry_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/memory_safety_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/optional_types.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/optional_types.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/optional_types_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/reference_resolver.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/reference_resolver.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/reference_resolver_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/regex_precompilation.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/regex_precompilation.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/regex_precompilation_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/register_function_helper.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime_builder_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime_builder_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime_issue.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/runtime_options.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard_runtime_builder_factory.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard_runtime_builder_factory.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard_runtime_builder_factory_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/type_registry.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/type_registry.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/activation_attribute_matcher_access.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/activation_attribute_matcher_access.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/attribute_matcher.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/convert_constant.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/convert_constant.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/errors.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/errors.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/function_adapter.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/function_adapter_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/issue_collector.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/issue_collector_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/legacy_runtime_type_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_env.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_env.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_env_testing.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_env_testing.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_friend_access.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_type_provider.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/internal/runtime_type_provider.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/arithmetic_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/arithmetic_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/arithmetic_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/comparison_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/comparison_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/comparison_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_membership_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_membership_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/container_membership_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/equality_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/equality_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/equality_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/logical_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/logical_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/logical_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/regex_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/regex_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/regex_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/string_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/string_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/string_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/time_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/time_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/time_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/type_conversion_functions.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/type_conversion_functions.h
Step #3 - "compile-libfuzzer-coverage-x86_64": runtime/standard/type_conversion_functions_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/cel_expression_source.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/cel_test_context.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/cel_test_factories.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/coverage_index.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/coverage_index.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/coverage_index_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/coverage_reporting.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/coverage_reporting.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/runner_bin.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/runner_lib.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/runner_lib.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/runner_lib_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/resources/
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/user_tests/
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/user_tests/checked_expr_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/user_tests/raw_expr_and_cel_file_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/user_tests/raw_expression_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testing/testrunner/user_tests/simple.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/baseline_tests.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/baseline_tests.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/baseline_tests_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/expr_printer.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/expr_printer.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/expr_printer_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/test_macros.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/test_macros.h
Step #3 - "compile-libfuzzer-coverage-x86_64": testutil/util.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/branch_coverage.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/branch_coverage.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/branch_coverage_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_field_extractor.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_field_extractor.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_field_extractor_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_unparser.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_unparser.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/cel_unparser_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/descriptor_pool_builder.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/descriptor_pool_builder.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/descriptor_pool_builder_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/flatbuffers_backed_impl.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/flatbuffers_backed_impl.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/flatbuffers_backed_impl_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/navigable_ast.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/navigable_ast.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/navigable_ast_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/proto_to_predicate.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/proto_to_predicate.h
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/proto_to_predicate_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": tools/testdata/
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/ast_depth_validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/ast_depth_validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/ast_depth_validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/comprehension_nesting_validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/comprehension_nesting_validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/comprehension_nesting_validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/homogeneous_literal_validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/homogeneous_literal_validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/homogeneous_literal_validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/regex_validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/regex_validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/regex_validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/timestamp_literal_validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/timestamp_literal_validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/timestamp_literal_validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/validator.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/validator.h
Step #3 - "compile-libfuzzer-coverage-x86_64": validator/validator_test.cc
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": sent 64,085,379 bytes  received 105,799 bytes  42,794,118.67 bytes/sec
Step #3 - "compile-libfuzzer-coverage-x86_64": total size is 63,650,827  speedup is 0.99
Finished Step #3 - "compile-libfuzzer-coverage-x86_64"
Starting Step #4
Step #4: Pulling image: gcr.io/oss-fuzz-base/base-runner
Step #4: Using default tag: latest
Step #4: latest: Pulling from oss-fuzz-base/base-runner
Step #4: b549f31133a9: Already exists
Step #4: 165118fe1b27: Already exists
Step #4: b206845c4ac0: Already exists
Step #4: 7883314084db: Pulling fs layer
Step #4: 01c0641ee6b0: Pulling fs layer
Step #4: 4dbff512f3de: Pulling fs layer
Step #4: 1c57f4604fb8: Pulling fs layer
Step #4: f13d532ec4d9: Pulling fs layer
Step #4: 552ee45c3721: Pulling fs layer
Step #4: 775721469a26: Pulling fs layer
Step #4: 7477c2b39de5: Pulling fs layer
Step #4: a94048add147: Pulling fs layer
Step #4: 15765c47f4c5: Pulling fs layer
Step #4: 26a4536ccbdd: Pulling fs layer
Step #4: 0c03017dddfa: Pulling fs layer
Step #4: 29cb6988f10e: Pulling fs layer
Step #4: 71a30a74433b: Pulling fs layer
Step #4: 76003e750087: Pulling fs layer
Step #4: 242a93fd740b: Pulling fs layer
Step #4: eb3e77cc3e2b: Pulling fs layer
Step #4: 1120964d019c: Pulling fs layer
Step #4: 1254d9fe4878: Pulling fs layer
Step #4: dfaf45321105: Pulling fs layer
Step #4: fcb1a2a5800e: Pulling fs layer
Step #4: 15765c47f4c5: Waiting
Step #4: 26a4536ccbdd: Waiting
Step #4: 0c03017dddfa: Waiting
Step #4: ed7002447a47: Pulling fs layer
Step #4: 29cb6988f10e: Waiting
Step #4: a1730a4e9dfb: Pulling fs layer
Step #4: 71a30a74433b: Waiting
Step #4: 1285af4eb5ee: Pulling fs layer
Step #4: 76003e750087: Waiting
Step #4: 93e25e662c9a: Pulling fs layer
Step #4: 242a93fd740b: Waiting
Step #4: 775721469a26: Waiting
Step #4: dfaf45321105: Waiting
Step #4: eb3e77cc3e2b: Waiting
Step #4: fcb1a2a5800e: Waiting
Step #4: 7477c2b39de5: Waiting
Step #4: a94048add147: Waiting
Step #4: 1120964d019c: Waiting
Step #4: a1730a4e9dfb: Waiting
Step #4: 93e25e662c9a: Waiting
Step #4: ed7002447a47: Waiting
Step #4: 4dbff512f3de: Verifying Checksum
Step #4: 4dbff512f3de: Download complete
Step #4: 7883314084db: Verifying Checksum
Step #4: 7883314084db: Download complete
Step #4: 1c57f4604fb8: Verifying Checksum
Step #4: 1c57f4604fb8: Download complete
Step #4: 775721469a26: Verifying Checksum
Step #4: 775721469a26: Download complete
Step #4: 01c0641ee6b0: Verifying Checksum
Step #4: 01c0641ee6b0: Download complete
Step #4: f13d532ec4d9: Verifying Checksum
Step #4: f13d532ec4d9: Download complete
Step #4: 7477c2b39de5: Download complete
Step #4: 7883314084db: Pull complete
Step #4: a94048add147: Verifying Checksum
Step #4: a94048add147: Download complete
Step #4: 29cb6988f10e: Verifying Checksum
Step #4: 29cb6988f10e: Download complete
Step #4: 0c03017dddfa: Download complete
Step #4: 26a4536ccbdd: Verifying Checksum
Step #4: 26a4536ccbdd: Download complete
Step #4: 552ee45c3721: Verifying Checksum
Step #4: 552ee45c3721: Download complete
Step #4: 76003e750087: Download complete
Step #4: 01c0641ee6b0: Pull complete
Step #4: 4dbff512f3de: Pull complete
Step #4: 1120964d019c: Verifying Checksum
Step #4: 1120964d019c: Download complete
Step #4: eb3e77cc3e2b: Verifying Checksum
Step #4: eb3e77cc3e2b: Download complete
Step #4: fcb1a2a5800e: Verifying Checksum
Step #4: fcb1a2a5800e: Download complete
Step #4: 15765c47f4c5: Download complete
Step #4: dfaf45321105: Download complete
Step #4: 1c57f4604fb8: Pull complete
Step #4: a1730a4e9dfb: Verifying Checksum
Step #4: a1730a4e9dfb: Download complete
Step #4: f13d532ec4d9: Pull complete
Step #4: ed7002447a47: Verifying Checksum
Step #4: ed7002447a47: Download complete
Step #4: 93e25e662c9a: Download complete
Step #4: 1254d9fe4878: Verifying Checksum
Step #4: 1254d9fe4878: Download complete
Step #4: 71a30a74433b: Verifying Checksum
Step #4: 71a30a74433b: Download complete
Step #4: 1285af4eb5ee: Download complete
Step #4: 242a93fd740b: Verifying Checksum
Step #4: 242a93fd740b: Download complete
Step #4: 552ee45c3721: Pull complete
Step #4: 775721469a26: Pull complete
Step #4: 7477c2b39de5: Pull complete
Step #4: a94048add147: Pull complete
Step #4: 15765c47f4c5: Pull complete
Step #4: 26a4536ccbdd: Pull complete
Step #4: 0c03017dddfa: Pull complete
Step #4: 29cb6988f10e: Pull complete
Step #4: 71a30a74433b: Pull complete
Step #4: 76003e750087: Pull complete
Step #4: 242a93fd740b: Pull complete
Step #4: eb3e77cc3e2b: Pull complete
Step #4: 1120964d019c: Pull complete
Step #4: 1254d9fe4878: Pull complete
Step #4: dfaf45321105: Pull complete
Step #4: fcb1a2a5800e: Pull complete
Step #4: ed7002447a47: Pull complete
Step #4: a1730a4e9dfb: Pull complete
Step #4: 1285af4eb5ee: Pull complete
Step #4: 93e25e662c9a: Pull complete
Step #4: Digest: sha256:852ff3b49f88e31ecfd5740b6962f7b1b58b5c2318f4f80e7531bdd89e071bcc
Step #4: Status: Downloaded newer image for gcr.io/oss-fuzz-base/base-runner:latest
Step #4: gcr.io/oss-fuzz-base/base-runner:latest
Finished Step #4
Starting Step #5
Step #5: Already have image (with digest): gcr.io/oss-fuzz-base/base-runner
Step #5: [/corpus/fuzz_parse.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/fuzz_parse.zip or
Step #5:         /corpus/fuzz_parse.zip.zip, and cannot find /corpus/fuzz_parse.zip.ZIP, period.
Step #5: Failed to unpack the corpus for fuzz_parse. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: ********************************************************************************
Step #5: Code coverage report generation failed.
Step #5: To reproduce, run:
Step #5: python infra/helper.py build_image cel-cpp
Step #5: python infra/helper.py build_fuzzers --sanitizer coverage cel-cpp
Step #5: python infra/helper.py coverage cel-cpp
Step #5: ********************************************************************************
Finished Step #5
ERROR
ERROR: build step 5 "gcr.io/oss-fuzz-base/base-runner" failed: step exited with non-zero status: 1